diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 1d025c7bb..49329846b 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -704,6 +704,16 @@ cleanup in separate work.
 Follow [WRITING.md](../WRITING.md#commits) for commit messages and
 [AGENTS.md](../AGENTS.md#repository-boundaries) for push and deployment limits.
 
+### Raku source-bound documentation checks
+
+The Raku command-usage scanner parses the library with the compiler that the
+library revision pins in `.tool-versions`, and with `JSON::Fast` installed.
+Put that `raku` on `PATH`, or set `LIBTMUX_DOCS_RAKU` to its executable; a
+missing or different compiler fails the scan. RakuAST can run trusted
+compile-time code, so the scanner reads only reviewed library revisions. CI
+reads the compiler from the committed API model and installs `JSON::Fast`
+before it runs the fixture.
+
 ### Perl source-bound documentation checks
 
 The reusable port builder checks the selected Perl artifact after rendering.
diff --git a/.github/workflows/port-docs.yml b/.github/workflows/port-docs.yml
index a72fac675..b4e2dce39 100644
--- a/.github/workflows/port-docs.yml
+++ b/.github/workflows/port-docs.yml
@@ -617,6 +617,36 @@ jobs:
           perl scripts/export-api.pl --revision "$SOURCE_SHA" \
             --exporter-revision "$SOURCE_SHA" --output docs/_build/api.json
 
+      - name: Read the selected Raku documentation runtime
+        if: matrix.port == 'raku'
+        id: raku-runtime
+        working-directory: port
+        run: |
+          python3 - <<'PYCODE'
+          import os, pathlib, re
+          rows = [line.split() for line in pathlib.Path('.tool-versions').read_text().splitlines()]
+          versions = [row[1] for row in rows if len(row) == 2 and row[0] == 'raku']
+          if len(versions) != 1 or not re.fullmatch(r'[0-9]{4}\.[0-9]{2}', versions[0]):
+              raise ValueError('Raku documentation requires an exact compiler pin')
+          with open(os.environ['GITHUB_OUTPUT'], 'a') as output:
+              output.write(f'version={versions[0]}\n')
+          PYCODE
+      - name: Install the selected Raku compiler
+        if: matrix.port == 'raku'
+        uses: Raku/setup-raku@8602b3572876ee7a5e304837c3183cf913a78f47 # v1.15.0
+        with:
+          raku-version: ${{ steps.raku-runtime.outputs.version }}
+      - name: Export the selected Raku declarations and native RakuDoc
+        if: matrix.port == 'raku'
+        working-directory: port
+        run: |
+          set -euo pipefail
+          zef install --/test --deps-only .
+          raku -I. tools/export-docs.raku
+      - name: Install the Raku usage scanner dependency
+        if: matrix.port == 'raku'
+        run: zef install --/test JSON::Fast
+
       - name: Install Common Lisp documentation toolchain
         if: matrix.port == 'lisp'
         uses: jdx/mise-action@b44d12e7d0d8ee7461bb893e1b1993500433185b # v5.2.7
@@ -816,6 +846,11 @@ jobs:
         working-directory: docs
         run: time pnpm run --recursive type-check
 
+      - name: Check the Raku native model adapter
+        if: matrix.port == 'raku'
+        working-directory: docs
+        run: time node site/node_modules/vitest/vitest.mjs run --root packages/api-model test/raku.test.ts
+
       # The version directory itself: its contents become
       # <locale>/<port>/<version>.
       - id: content
diff --git a/.github/workflows/reusable-deploy.yml b/.github/workflows/reusable-deploy.yml
index ff2006894..f1d36a906 100644
--- a/.github/workflows/reusable-deploy.yml
+++ b/.github/workflows/reusable-deploy.yml
@@ -144,7 +144,7 @@ jobs:
             echo "::error::path-prefix '$p' must be an unrooted path using letters, digits, '.', '_', '-' and '/', without '..'" >&2
             exit 1
           fi
-          reserved=(py ruby lua powershell julia erlang elixir haskell lisp ts rs go java clojure kotlin scala csharp fsharp cxx swift ocaml perl manifest _shell)
+          reserved=(py ruby lua powershell julia erlang elixir haskell lisp ts rs go java clojure kotlin scala csharp fsharp cxx swift ocaml perl raku manifest _shell)
           for r in "${reserved[@]}"; do
             if [[ "$p" == "$r" ]]; then
               echo "::error::path-prefix '$p' is a bare reserved top-level name — qualify it, e.g. '$r/latest'" >&2
@@ -153,7 +153,7 @@ jobs:
           done
           if [[ -n "${PORT_IN:-}" ]]; then
             case "$PORT_IN" in
-              py|ruby|lua|powershell|julia|erlang|elixir|haskell|lisp|ts|rs|go|java|clojure|kotlin|scala|csharp|fsharp|cxx|swift|ocaml|perl) ;;
+              py|ruby|lua|powershell|julia|erlang|elixir|haskell|lisp|ts|rs|go|java|clojure|kotlin|scala|csharp|fsharp|cxx|swift|ocaml|perl|raku) ;;
               *) echo "::error::unknown port '$PORT_IN'" >&2; exit 1 ;;
             esac
             if [[ ! "$VERSION_IN" =~ ^[a-zA-Z0-9][a-zA-Z0-9._-]*$ || "$VERSION_IN" == *..* ]]; then
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index a78bab14d..7ab699b93 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -65,6 +65,7 @@ jobs:
           } >> "$GITHUB_OUTPUT"
           echo "lisp=$(jq -r .revision site/src/data/api/lisp.json)" >> "$GITHUB_OUTPUT"
           echo "erlang=$(jq -r .revision site/src/data/api/erlang.json)" >> "$GITHUB_OUTPUT"
+          echo "raku=$(jq -r .revision site/src/data/api/raku.json)" >> "$GITHUB_OUTPUT"
 
       - uses: actions/checkout@v7
         with:
@@ -126,6 +127,24 @@ jobs:
           ref: ${{ steps.integrated-sources.outputs.erlang }}
           path: .port-sources/erlang
           persist-credentials: false
+      - uses: actions/checkout@v7
+        with:
+          repository: libtmux/libtmux-raku
+          ref: ${{ steps.integrated-sources.outputs.raku }}
+          path: .port-sources/raku
+          persist-credentials: false
+
+      # The usage scanner parses library source with the compiler that revision pins; RakuAST can run compile-time code.
+      - name: Read the integrated Raku compiler
+        id: raku-runtime
+        run: |
+          version=$(jq -er '.nativeProvenance.exporter.compiler | select(test("^[0-9]{4}\\.[0-9]{2}$"))' site/src/data/api/raku.json)
+          printf 'version=%s\n' "$version" >> "$GITHUB_OUTPUT"
+      - uses: Raku/setup-raku@8602b3572876ee7a5e304837c3183cf913a78f47 # v1.15.0
+        with:
+          raku-version: ${{ steps.raku-runtime.outputs.version }}
+      - name: Install the Raku scanner dependency
+        run: zef install --/test JSON::Fast
 
       # The exporter tests compile a fixture with the package's own toolchain:
       # the exact pair the integrated Elixir source pins, read as port-docs.yml
@@ -197,6 +216,7 @@ jobs:
           LIBTMUX_DOCS_CHECKOUT_PERL: ${{ github.workspace }}/.port-sources/perl
           LIBTMUX_DOCS_CHECKOUT_LISP: ${{ github.workspace }}/.port-sources/lisp
           LIBTMUX_DOCS_CHECKOUT_ERLANG: ${{ github.workspace }}/.port-sources/erlang
+          LIBTMUX_DOCS_CHECKOUT_RAKU: ${{ github.workspace }}/.port-sources/raku
         run: |
           node scripts/stage-port-docs.mjs --from-source
           node scripts/stage-port-docs.mjs --cached --check
@@ -220,6 +240,7 @@ jobs:
           LIBTMUX_DOCS_CHECKOUT_LUA: ${{ github.workspace }}/.port-sources/lua
           LIBTMUX_DOCS_CHECKOUT_OCAML: ${{ github.workspace }}/.port-sources/ocaml
           LIBTMUX_DOCS_CHECKOUT_LISP: ${{ github.workspace }}/.port-sources/lisp
+          LIBTMUX_DOCS_CHECKOUT_RAKU: ${{ github.workspace }}/.port-sources/raku
           # PowerShell, Julia, Elixir, Haskell and Perl paths stay scoped to guide staging
           # above, which checks the cache used by ordinary builds. Native API
           # and MCP export freshness remain owning-port checks, not claims of
@@ -228,7 +249,7 @@ jobs:
           # OCaml's checkout also feeds source-derived usage checks. Its
           # compiled API is qualified by the owning port's exporter job.
           # Common Lisp's checkout stays available here so example sources are checked against the exact revision.
-          LIBTMUX_DOCS_SKIP_NATIVE_MODEL_PORTS: ruby,lua,powershell,julia,elixir,ocaml,haskell,perl,lisp,erlang
+          LIBTMUX_DOCS_SKIP_NATIVE_MODEL_PORTS: ruby,lua,powershell,julia,elixir,ocaml,haskell,perl,lisp,erlang,raku
 
       - name: Upload audited preview
         if: github.event_name == 'pull_request'
diff --git a/.github/workflows/verify-destinations.yml b/.github/workflows/verify-destinations.yml
index 2a498ffbe..0aa4bc504 100644
--- a/.github/workflows/verify-destinations.yml
+++ b/.github/workflows/verify-destinations.yml
@@ -69,6 +69,14 @@ jobs:
         if: ${{ !cancelled() }}
         run: node scripts/verify-api-destinations.mjs --check --fresh
 
+      # A Perl reference page links to the POD of the latest CPAN release. When
+      # a release lands the record is stale, so this names the distribution
+      # and its old and new release; commit the output of
+      # node scripts/gen-perl-pod.mjs with the change that follows.
+      - name: Check the recorded Perl POD release against MetaCPAN
+        if: ${{ !cancelled() }}
+        run: node scripts/gen-perl-pod.mjs --check
+
       - name: Keep the fresh evidence
         if: ${{ !cancelled() }}
         uses: actions/upload-artifact@v7
diff --git a/notes/branding.md b/notes/branding.md
index 5cbd40552..50ffec4b2 100644
--- a/notes/branding.md
+++ b/notes/branding.md
@@ -38,6 +38,15 @@ and neutral reading surfaces. Its library cards describe the repository
 scaffold without an API example. Provenance is recorded in
 [`perl/source.json`](../site/public/brand/perl/source.json).
 
+Raku uses the library set from assets revision
+`55dd6eac4347ba22270788b74a71ec0cba12e287`, with Linguist's `#0000fb` primary.
+Its link and filled-control shades are darker in light mode and lighter in dark
+mode; reading surfaces stay neutral. Only the library set is included because
+the port publishes no workspace or MCP product. The port switcher shows the
+library tile, labelled as libtmux for Raku rather than as the Raku language
+logo. Digests and the shared-root manifest overrides are recorded in
+[`raku/source.json`](../site/public/brand/raku/source.json).
+
 - [GitHub Linguist colors](https://github.com/github-linguist/linguist/blob/538da05f034fa5c83bd81df128d144e208898da3/lib/linguist/languages.yml)
 - The original libtmux and tmuxp geometry was supplied by the project owner.
 - The MCP overlay uses the symbol, without the wordmark, from the
diff --git a/packages/api-model/src/builtins.ts b/packages/api-model/src/builtins.ts
index 04472f6d7..cf70172d7 100644
--- a/packages/api-model/src/builtins.ts
+++ b/packages/api-model/src/builtins.ts
@@ -156,6 +156,10 @@ export const BUILTINS: Record<string, Record<string, string>> = {
   erlang: {
     'erl_error:format_exception/3': 'https://www.erlang.org/doc/apps/stdlib/erl_error.html#format_exception/3',
   },
+  raku: {
+    Promise: 'https://docs.raku.org/type/Promise',
+    Supply: 'https://docs.raku.org/type/Supply',
+  },
   ocaml: {
     Iarray: 'https://ocaml.org/manual/5.5/api/Iarray.html',
     'Iarray.t': 'https://ocaml.org/manual/5.5/api/Iarray.html#TYPEt',
diff --git a/packages/api-model/src/concepts.ts b/packages/api-model/src/concepts.ts
index 09be240fa..7733f1c6b 100644
--- a/packages/api-model/src/concepts.ts
+++ b/packages/api-model/src/concepts.ts
@@ -4144,8 +4144,98 @@ for (const [id, binding] of Object.entries(CLOJURE_CONCEPTS)) {
   concept.symbols.clojure = binding.symbol
   if (binding.note) (concept.notes ??= {}).clojure = binding.note
 }
+const RAKU_CONCEPTS: Record<string, { symbol: string; note?: string }> = {
+  server: { symbol: 'LibTmux::Server' },
+  session: { symbol: 'LibTmux::Model::Session' },
+  window: { symbol: 'LibTmux::Model::Window', note: 'A physical window may have multiple WindowLink placements, including distinct indexes in one session.' },
+  pane: { symbol: 'LibTmux::Model::Pane' },
+  snapshot: { symbol: 'LibTmux::Server.snapshot', note: 'Explicit I/O captures an observation interval. Existing views and relationships remain local.' },
+  'list-sessions': { symbol: 'LibTmux::Model::Snapshot.sessions' },
+  'list-server-windows': { symbol: 'LibTmux::Model::Snapshot.windows', note: 'Physical windows occur once; window-links preserves placements.' },
+  'list-server-panes': { symbol: 'LibTmux::Model::Snapshot.panes' },
+  'list-clients': { symbol: 'LibTmux::Model::Snapshot.clients' },
+  'list-windows': { symbol: 'LibTmux::Model::Session.window-links', note: 'Returns captured WindowLink placements. Follow each window relationship for the physical window.' },
+  'list-panes': { symbol: 'LibTmux::Model::Window.panes' },
+  'pane-window': { symbol: 'LibTmux::Model::Pane.window' },
+  'window-session': { symbol: 'LibTmux::Model::WindowLink.session', note: 'The session belongs to a link, not to the physical Window.' },
+  'window-link-window': { symbol: 'LibTmux::Model::WindowLink.window' },
+  'client-session': { symbol: 'LibTmux::Model::Client.session' },
+  'active-pane': { symbol: 'LibTmux::Model::Window.active-pane' },
+  'active-window': { symbol: 'LibTmux::Model::Session.current-link', note: 'Returns the captured active WindowLink; its window relationship selects the physical window.' },
+  'new-session': { symbol: 'LibTmux::Server.new-session' },
+  'start-server': { symbol: 'LibTmux::Server.start', note: 'Starts an owned private daemon; close stops only an owned incarnation.' },
+  'kill-server': { symbol: 'LibTmux::Server.kill-server', note: 'Explicitly terminates the observed daemon. Owned callers still close to join cleanup.' },
+  'server-from-env': { symbol: 'LibTmux::Server.from-env', note: 'Explicitly imports TMUX environment data, verifies the daemon PID and binds that incarnation.' },
+  'has-session': { symbol: 'LibTmux::Server.has-session', note: 'Checks one exact ID or name; acquisition and identity failures still throw.' },
+  'run-shell': { symbol: 'LibTmux::Server.run-shell', note: 'Background acknowledgement does not establish job completion.' },
+  'if-shell': { symbol: 'LibTmux::Server.if-shell', note: 'Branches use bounded Invocation values; the condition explicitly selects shell or FORMAT semantics.' },
+  'source-file': { symbol: 'LibTmux::Server.source-file', note: 'Sources a literal pathname; parse-only validates without executing commands.' },
+  'wait-for': { symbol: 'LibTmux::Server.wait-for', note: 'Waits, signals, locks or unlocks a named channel within the Server deadline.' },
+  'server-cmd': { symbol: 'LibTmux::Server.command' },
+  'attach-session': { symbol: 'LibTmux::Server.attach', note: 'Returns a separately owned attachment with an explicit lifecycle.' },
+  'server-version': { symbol: 'LibTmux::Server.capabilities', note: 'Client and observed daemon versions are distinct capability inputs.' },
+  'chain-commands': { symbol: 'LibTmux::Server.run-batch', note: 'Returns per-operation evidence and partial results; this is not a transaction.' },
+}
+for (const [owner, bindings] of Object.entries({
+  SessionRef: { 'new-window': 'new-window', 'kill-session': 'kill', 'rename-session': 'rename', 'session-cmd': 'command',
+    'refresh-session': 'inspect', 'next-window': 'next-window', 'previous-window': 'previous-window', 'last-window': 'last-window',
+    'detach-session-clients': 'detach-clients', 'lock-session': 'lock' },
+  WindowRef: { 'kill-window': 'kill', 'rename-window': 'rename', 'window-cmd': 'command', 'refresh-window': 'inspect',
+    'select-layout': 'select-layout', 'next-layout': 'next-layout', 'previous-layout': 'previous-layout', 'resize-window': 'resize',
+    'respawn-window': 'respawn', 'link-window': 'link', 'rotate-panes': 'rotate', 'last-pane': 'last-pane' },
+  WindowLinkRef: { 'unlink-window': 'unlink', 'move-window': 'move', 'swap-window': 'swap', 'select-window': 'select' },
+  PaneRef: { 'capture-pane': 'capture', 'send-keys': 'send-keys', 'split-pane': 'split', 'respawn-pane': 'respawn',
+    'resize-pane': 'resize', 'kill-pane': 'kill', 'break-pane': 'break', 'join-pane': 'join', 'move-pane': 'move', 'swap-pane': 'swap',
+    'pipe-pane': 'pipe', 'select-pane': 'select', 'clear-history': 'clear-history', 'set-pane-title': 'set-title',
+    'copy-mode': 'copy-mode', 'clock-mode': 'clock-mode', 'send-prefix': 'send-prefix', 'reset-pane': 'reset',
+    'pane-cmd': 'command', 'refresh-pane': 'inspect' },
+  ClientRef: { 'detach-client': 'detach', 'refresh-client': 'refresh', 'switch-client': 'switch', 'lock-client': 'lock',
+    'suspend-client': 'suspend', 'display-menu': 'menu-async', 'display-popup': 'popup-async', 'command-prompt': 'prompt-async',
+    'confirm-before': 'confirm-async', 'prompt-history': 'prompt-history', 'clear-prompt-history': 'clear-prompt-history',
+    'find-window': 'find-window' },
+})) for (const [concept, method] of Object.entries(bindings)) RAKU_CONCEPTS[concept] = { symbol: `LibTmux::Model::${owner}.${method}` }
+for (const [prefix, owner, fields] of [
+  ['session', 'Session', ['id', 'name', 'created', 'path', 'group', 'grouped']],
+  ['window', 'Window', ['id', 'name', 'height', 'width', 'layout', 'linked']],
+  ['pane', 'Pane', ['id', 'index', 'height', 'width', 'title', 'active', 'current-command', 'current-path', 'pid', 'tty', 'dead', 'in-mode', 'window-id']],
+  ['window', 'WindowLink', ['index', 'active', 'session-id']],
+] as const) for (const field of fields) RAKU_CONCEPTS[`${prefix}-${field}`] = { symbol: `LibTmux::Model::${owner}.${field}` }
+for (const scope of ['server', 'session', 'window', 'pane']) {
+  for (const [suffix, method] of Object.entries({ options: 'entries', option: 'get' })) RAKU_CONCEPTS[`${scope}-${suffix}`] = {
+    symbol: `LibTmux::Configuration::Options.${method}`, note: 'Use the corresponding server or reference options facade; acquisition is explicit.' }
+  for (const method of ['set', 'unset']) RAKU_CONCEPTS[`${method}-${scope}-option`] = { symbol: `LibTmux::Configuration::Options.${method}` }
+  RAKU_CONCEPTS[`${scope}-hooks`] = { symbol: 'LibTmux::Configuration::Hooks.list', note: 'Use the explicitly scoped hooks facade.' }
+  for (const method of ['set', 'unset']) RAKU_CONCEPTS[`${method}-${scope}-hook`] = { symbol: `LibTmux::Configuration::Hooks.${method}` }
+}
+for (const scope of ['server', 'session']) {
+  RAKU_CONCEPTS[`${scope}-environment`] = { symbol: 'LibTmux::Configuration::Environment.list', note: 'Use the corresponding server or session environment facade.' }
+  RAKU_CONCEPTS[`${scope}-get-environment`] = { symbol: 'LibTmux::Configuration::Environment.get' }
+  for (const method of ['set', 'unset', 'remove']) RAKU_CONCEPTS[`${method}-${scope}-environment`] = { symbol: `LibTmux::Configuration::Environment.${method}` }
+}
+for (const [concept, method] of Object.entries({ 'list-buffers': 'list', 'show-buffer': 'get', 'set-buffer': 'put', 'delete-buffer': 'delete', 'paste-buffer': 'paste' })) {
+  RAKU_CONCEPTS[concept] = { symbol: `LibTmux::Configuration::Buffers.${method}`, note: 'Buffer content is byte data; file I/O remains a separate caller operation.' }
+}
+for (const [concept, method] of Object.entries({ 'list-keys': 'list', 'bind-key': 'bind', 'unbind-key': 'unbind' })) RAKU_CONCEPTS[concept] = { symbol: `LibTmux::Configuration::KeyBindings.${method}` }
+for (const [id, binding] of Object.entries(RAKU_CONCEPTS)) {
+  const concept = CONCEPTS[id]
+  if (!concept) throw new Error(`concepts: Raku maps unknown concept ${id}`)
+  concept.symbols.raku = binding.symbol
+  if (binding.note) (concept.notes ??= {}).raku = binding.note
+}
+for (const [id, reason] of Object.entries({
+  'workspace-description': 'Workspace functionality is outside the Raku core library scope.',
+  'build-workspace': 'Workspace functionality is outside the Raku core library scope.',
+  'freeze-workspace': 'Workspace functionality is outside the Raku core library scope.',
+  'pane-session': 'A pane belongs to a physical window, which can have several session links. Traverse window.links and each link.session.',
+  'pane-session-id': 'A physical pane has no single session identity; inspect its window links.',
+  'session-from-env': 'Session targeting is explicit and incarnation-bound.',
+  'load-buffer': 'Read file bytes with native Raku I/O and pass them to Buffers.put.',
+  'save-buffer': 'Acquire bytes with Buffers.get and write them with native Raku I/O.',
+})) (CONCEPTS[id]!.absent ??= {}).raku = reason
+
 for (const concept of Object.values(CONCEPTS)) {
   concept.absent ??= {}
+  if (!concept.symbols.raku) concept.absent.raku ??= 'No direct Raku mapping is recorded for this operation; consult the native API reference.'
   if (!concept.symbols.powershell) concept.absent.powershell ??= 'No source-verified PowerShell equivalent is recorded for this operation.'
   if (!concept.symbols.julia) concept.absent.julia ??= 'No source-verified Julia equivalent is recorded for this operation.'
   if (!concept.symbols.elixir) concept.absent.elixir = 'No source-verified Elixir equivalent is recorded for this operation.'
diff --git a/packages/api-model/src/doc/roles.ts b/packages/api-model/src/doc/roles.ts
index a45540364..7cf2758ec 100644
--- a/packages/api-model/src/doc/roles.ts
+++ b/packages/api-model/src/doc/roles.ts
@@ -284,6 +284,8 @@ const SYNTAX: Record<string, ReadonlySet<string>> = {
   py: new Set(['rest', 'citation']),
   // Pod::Simple exports local POD targets as roles and external targets as Markdown links.
   perl: new Set(['pod', 'markdown-link']),
+  // The RakuDoc adapter resolves L<> links into roles; C<> stays literal code.
+  raku: new Set(['rest-role', 'markdown-link', 'literal-code']),
   rs: new Set(['intra-doc']),
   go: new Set(['go-link']),
   java: new Set(['jsdoc']),
diff --git a/packages/api-model/src/index.ts b/packages/api-model/src/index.ts
index 856684be4..12daf91b5 100644
--- a/packages/api-model/src/index.ts
+++ b/packages/api-model/src/index.ts
@@ -1,4 +1,5 @@
 export { extractPerlArtifact } from './languages/perl.ts'
+export { extractRakuArtifact } from './languages/raku.ts'
 export * from './model.ts'
 export * from './doc/prose-blocks.ts'
 export { sourceUrl, symbolsForProduct } from './products.ts'
diff --git a/packages/api-model/src/inventory.ts b/packages/api-model/src/inventory.ts
index 1be2c2b82..89b7a63c2 100644
--- a/packages/api-model/src/inventory.ts
+++ b/packages/api-model/src/inventory.ts
@@ -33,6 +33,7 @@ export function symbolEntries<T extends { type: string }>(entries: T[]): T[] {
 /** Sphinx v2 uses object types in records; roles resolve those types. */
 const DOMAIN: Record<PortSlug, string> = {
   perl: 'std',
+  raku: 'std',
   py: 'py',
   ruby: 'std',
   lua: 'std',
diff --git a/packages/api-model/src/languages/raku.ts b/packages/api-model/src/languages/raku.ts
new file mode 100644
index 000000000..40f758cc0
--- /dev/null
+++ b/packages/api-model/src/languages/raku.ts
@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto'
+import type { ApiModel, ApiSymbol, DocBlock } from '../model.ts'
+
+interface RakuArtifact extends ApiModel {
+  schema: string
+  workingTree: boolean
+  compiler: string
+  language: string
+  aliases: Record<string, string>
+  missingDocumentation: Record<string, { file: string; line: number }>
+}
+
+const SHA = /^[a-f0-9]{40}$/
+const HASH = /^[a-f0-9]{64}$/
+const relative = (path: string) => Boolean(path) && !path.startsWith('/') && !path.includes('\\') && !path.split('/').includes('..')
+const digest = (text: string) => createHash('sha256').update(text).digest('hex')
+
+function check(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(`Invalid Raku documentation artifact: ${message}`)
+}
+
+/** Adapt compiler declarations and native RakuDoc; never parse Raku source in JavaScript. */
+export function extractRakuArtifact(input: unknown, expectedRevision?: string): ApiModel {
+  const artifact = structuredClone(input) as RakuArtifact
+  check(artifact?.schema === 'libtmux.raku-api/v1' && artifact.port === 'raku' &&
+    artifact.repo === 'libtmux/libtmux-raku' && SHA.test(artifact.revision ?? ''), 'schema or library identity')
+  check(!expectedRevision || artifact.revision === expectedRevision, 'library revision mismatch')
+  check(typeof artifact.workingTree === 'boolean' && /^v?\d{4}\.\d{2}$/.test(artifact.compiler) && artifact.language === '6.d', 'native compiler profile')
+  const producer = artifact.nativeProvenance?.exporter
+  const library = artifact.nativeProvenance?.library
+  check(library?.repository === artifact.repo && library.revision === artifact.revision &&
+    library.workingTree === artifact.workingTree, 'library provenance differs')
+  check(producer?.name === 'RakuAST and RakuDoc export' && producer.version === 1 &&
+    producer.repository === artifact.repo && typeof producer.revision === 'string' && SHA.test(producer.revision) &&
+    producer.path === 'tools/export-docs.raku' && typeof producer.sha256 === 'string' && HASH.test(producer.sha256) &&
+    typeof producer.workingTree === 'boolean', 'exporter identity')
+  check(!artifact.workingTree && !producer.workingTree, 'uncommitted inputs cannot be published')
+  producer.compiler = artifact.compiler.replace(/^v/, '')
+  check(Array.isArray(artifact.nativeProvenance?.files) && artifact.nativeProvenance.files.length > 0 &&
+    artifact.generatedSources && typeof artifact.generatedSources === 'object', 'source inventory')
+  const files = new Map<string, string>()
+  for (const file of artifact.nativeProvenance.files) {
+    check(relative(file.path) && HASH.test(file.sha256) && !files.has(file.path), 'invalid or repeated source path')
+    files.set(file.path, file.sha256)
+  }
+  for (const [path, text] of Object.entries(artifact.generatedSources)) {
+    check(relative(path) && files.has(path) && typeof text === 'string' && digest(text) === files.get(path), `source digest differs: ${path}`)
+  }
+  check(Array.isArray(artifact.symbols) && artifact.symbols.length > 0, 'empty public API')
+  const ids = new Map(artifact.symbols.map((symbol) => [symbol.id, symbol]))
+  check(ids.size === artifact.symbols.length, 'repeated public identity')
+  const aliases = artifact.aliases ?? {}
+  const resolve = (name: string, owner: ApiSymbol): string => {
+    if (ids.has(name)) return name
+    if (aliases[name] && ids.has(aliases[name])) return aliases[name]
+    const scoped = `${owner.parent ?? owner.id}::${name}`
+    if (ids.has(scoped)) return scoped
+    if (aliases[scoped] && ids.has(aliases[scoped])) return aliases[scoped]
+    const candidates = artifact.symbols.filter((symbol) => symbol.name === name)
+    check(candidates.length === 1, `unresolved or ambiguous RakuDoc target ${name} in ${owner.id}`)
+    return candidates[0]!.id
+  }
+  const prose = (text: string, owner: ApiSymbol): string => text.replace(/\[([^\]]+)\]\(rakudoc:([^)]+)\)/g,
+    (_match, label: string, encoded: string) => {
+      let target: string
+      try { target = decodeURIComponent(encoded) } catch { throw new Error('Invalid RakuDoc target encoding') }
+      return `:obj:\`${label.replaceAll('`', '')} <${resolve(target, owner)}>\``
+    })
+  const docs = (value: DocBlock | undefined, owner: ApiSymbol): DocBlock | undefined => value ? {
+    ...value, summary: prose(value.summary ?? '', owner), ...(value.body ? { body: prose(value.body, owner) } : {}),
+  } : undefined
+  for (const symbol of artifact.symbols) {
+    check(symbol.apiScope === 'exported' && symbol.product === 'core' && symbol.package === 'LibTmux' &&
+      /^(?:LibTmux|X::LibTmux)(?:::|\.|$)/.test(symbol.id) && symbol.publicId === symbol.id &&
+      (!symbol.parent || ids.has(symbol.parent)), `invalid public declaration ${symbol.id}`)
+    check(relative(symbol.source?.file) && files.has(symbol.source.file) &&
+      artifact.generatedSources[symbol.source.file] !== undefined &&
+      Number.isInteger(symbol.source.line) && symbol.source.line! > 0 &&
+      symbol.source.line! <= artifact.generatedSources[symbol.source.file]!.split('\n').length &&
+      symbol.source.revision === artifact.revision, `source identity differs: ${symbol.id}`)
+    check(Array.isArray(symbol.signatures), `missing signatures: ${symbol.id}`)
+    // Raku declares a top-level class by its package path; the shared model names a type by its last segment.
+    symbol.name = symbol.name.split('::').at(-1)!
+    for (const signature of symbol.signatures) {
+      check(typeof signature.raw === 'string' && signature.raw.length > 0 && Array.isArray(signature.params), `invalid native signature: ${symbol.id}`)
+      let previous = -1
+      for (const reference of signature.references ?? []) {
+        check(Number.isInteger(reference.start) && Number.isInteger(reference.end) && reference.start >= 0 &&
+          reference.end > reference.start && reference.end <= signature.raw.length && reference.start >= previous &&
+          ids.has(reference.target), `invalid native type reference in ${symbol.id}: ${reference.target}`)
+        previous = reference.end
+      }
+      const start = signature.raw.indexOf(`${symbol.name}(`)
+      check(start >= 0, `missing native declaration name: ${symbol.id}`)
+      signature.nativeSyntax = [{ start, end: start + symbol.name.length, kind: 'name' }]
+      const ranges = [
+        { start, end: start + symbol.name.length, declaration: true },
+        ...(signature.references ?? []).map((reference) => ({ ...reference, declaration: false })),
+      ].sort((a, b) => a.start - b.start)
+      signature.nativeSpans = []
+      let offset = 0
+      for (const range of ranges) {
+        check(range.start >= offset, `overlapping native spans: ${symbol.id}`)
+        if (range.start > offset) signature.nativeSpans.push({ text: signature.raw.slice(offset, range.start) })
+        signature.nativeSpans.push({ text: signature.raw.slice(range.start, range.end),
+          ...('target' in range ? { target: range.target } : { declaration: true }) })
+        offset = range.end
+      }
+      if (offset < signature.raw.length) signature.nativeSpans.push({ text: signature.raw.slice(offset) })
+      signature.doc = docs(signature.doc, symbol)
+    }
+    symbol.doc = docs(symbol.doc, symbol)
+  }
+  return {
+    port: 'raku', repo: artifact.repo, revision: artifact.revision,
+    extractor: artifact.extractor, symbols: artifact.symbols,
+    exportGroups: artifact.exportGroups,
+    // The captured sources only prove the digests above. The revision is public, so source links open GitHub at it.
+    nativeProvenance: artifact.nativeProvenance,
+  }
+}
diff --git a/packages/api-model/src/mentions.ts b/packages/api-model/src/mentions.ts
index 51bf786d6..b54b658bd 100644
--- a/packages/api-model/src/mentions.ts
+++ b/packages/api-model/src/mentions.ts
@@ -96,6 +96,7 @@ const FENCE_PORT: Record<string, string> = {
   elixir: 'elixir', ex: 'elixir', exs: 'elixir',
   perl: 'perl', pl: 'perl', pm: 'perl',
   lisp: 'lisp', 'common-lisp': 'lisp',
+  raku: 'raku',
 }
 
 /** A symbol that a link on a page names. */
diff --git a/packages/api-model/src/model.ts b/packages/api-model/src/model.ts
index 9ade56f16..0d7ed68cc 100644
--- a/packages/api-model/src/model.ts
+++ b/packages/api-model/src/model.ts
@@ -15,6 +15,7 @@
 
 /** Language libraries, by the slug the site uses. */
 export type PortSlug = 'perl' | 'py' | 'ruby' | 'lua' | 'ts' | 'rs' | 'go' | 'java' | 'csharp' | 'cxx' | 'swift' | 'kotlin' | 'scala' | 'fsharp' | 'powershell' | 'julia' | 'elixir' | 'ocaml' | 'haskell' | 'clojure' | 'lisp' | 'erlang'
+  | 'raku'
 
 export type ApiProduct = 'core' | 'workspace' | 'mcp'
 
@@ -384,6 +385,8 @@ export interface ApiModelBase {
   nativeProvenance?: {
     files: { path: string; sha256: string }[]
     exporter: Record<string, unknown>
+    /** The library revision a native exporter described, when it records one apart from the exporter's own. */
+    library?: { repository: string; revision: string; workingTree: boolean }
   }
   /** Generated public source files, stored with the revision that produced them. */
   generatedSources?: Record<string, string>
diff --git a/packages/api-model/src/nav-config.ts b/packages/api-model/src/nav-config.ts
index e2fcde918..e97da27e7 100644
--- a/packages/api-model/src/nav-config.ts
+++ b/packages/api-model/src/nav-config.ts
@@ -605,6 +605,17 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
       'libtmux.Watch': 'watch handle shared by several tmux objects',
     },
   },
+  raku: {
+    unsettled: {
+      LibTmux: 'public module spanning the task buckets; its exported declarations have their own placements',
+      'LibTmux::Configuration': 'namespace of the options, hooks, environment, buffer and key-binding facades; each facade has its own placement',
+      'LibTmux::Engine': 'module holding connection and daemon identity values placed under Server',
+      'LibTmux::Model': 'module of the captured objects and their references; each object has its own placement',
+      'LibTmux::Types': 'module of value types shared by every object; the outcome and state enums sit with their tasks',
+      'LibTmux::Types::Count': 'nonnegative count shared by every object, owned by none',
+      'LibTmux::Types::Positive': 'positive dimension shared by every object, owned by none',
+    },
+  },
   perl: {
     unsettled: {
       LibTmux: 'distribution namespace and version; concrete packages have their own placements',
@@ -893,6 +904,15 @@ const LANGUAGE_PLACEMENTS: Record<string, Record<string, string[]>> = {
   cxx: {
     workspace: ['BuildEvent', 'BuildPhase', 'BuildStop'].map((name) => `libtmux::workspace::${name}`),
   },
+  raku: {
+    client: ['LibTmux::Attachment'],
+    commands: ['LibTmux::Batch', 'LibTmux::Batch::Batch', 'LibTmux::Batch::Evidence', 'LibTmux::Batch::Operation', 'LibTmux::Batch::Report', 'LibTmux::Types::Outcome'],
+    version: ['LibTmux::Catalogue', 'LibTmux::Catalogue.catalogue', 'LibTmux::Catalogue.parse-tmux-version', 'LibTmux::Catalogue.support-policy',
+      'LibTmux::Catalogue::CatalogueData', 'LibTmux::Catalogue::SupportPolicy', 'LibTmux::Types::SupportState'],
+    server: ['LibTmux::Engine::Endpoint', 'LibTmux::Engine::Incarnation', 'LibTmux::Engine::Observation'],
+    queries: ['LibTmux::Selection', 'LibTmux::Selection::Selection'],
+    snapshots: ['LibTmux::Model::View', 'LibTmux::Types::ValueState'],
+  },
 }
 
 /** Free functions and cmdlets need the same discovery-first order as object members. */
@@ -960,7 +980,7 @@ function languageBucket(bucket: Bucket, port: string, root = bucket.id): Bucket
 }
 
 export const NAV: Record<string, PortNav> = Object.fromEntries(
-  ['perl', 'powershell', 'julia', 'elixir', 'lisp', 'erlang', 'py', 'ruby', 'lua', 'ts', 'rs', 'go', 'java', 'clojure', 'kotlin', 'scala', 'fsharp', 'csharp', 'cxx', 'swift', 'ocaml', 'haskell'].map((port) => [
+  ['perl', 'powershell', 'julia', 'elixir', 'lisp', 'erlang', 'py', 'ruby', 'lua', 'ts', 'rs', 'go', 'java', 'clojure', 'kotlin', 'scala', 'fsharp', 'csharp', 'cxx', 'swift', 'ocaml', 'haskell', 'raku'].map((port) => [
     port,
     {
       port,
diff --git a/packages/api-model/src/nav-sidecar.ts b/packages/api-model/src/nav-sidecar.ts
index 7210bc5ae..c38bdfd50 100644
--- a/packages/api-model/src/nav-sidecar.ts
+++ b/packages/api-model/src/nav-sidecar.ts
@@ -62,8 +62,10 @@ export function exportGroupsNav(model: ApiModelBase): NavConfig {
       }
       members.add(id)
     }
-    bucket.children!.push({ id: `${bucket.id}:${bucket.children!.length}`, label: group.title,
-      match: { kind: 'id', is: [...group.members] }, order: [...group.members] })
+    // A module exported by another module already owns a bucket; listing it here too would place it twice.
+    const declarations = group.members.filter((id) => !modules.has(byId.get(id)!.id))
+    if (declarations.length) bucket.children!.push({ id: `${bucket.id}:${bucket.children!.length}`, label: group.title,
+      match: { kind: 'id', is: declarations }, order: declarations })
   }
   for (const symbol of model.symbols) {
     if (symbol.kind === 'module' && publicSymbol(symbol) && !owners.has(symbol.publicId ?? symbol.id)) {
diff --git a/packages/api-model/src/prose.ts b/packages/api-model/src/prose.ts
index 25ef2bba6..825a91634 100644
--- a/packages/api-model/src/prose.ts
+++ b/packages/api-model/src/prose.ts
@@ -19,6 +19,7 @@ export const PORT_NAME: Record<string, string> = {
   ocaml: 'OCaml',
   py: 'Python',
   perl: 'Perl',
+  raku: 'Raku',
   ts: 'TypeScript',
   rs: 'Rust',
   go: 'Go',
@@ -240,6 +241,12 @@ const NOT_API: { why: string; test: RegExp }[] = [
   // A YAML key or a doc marker: `environment:`, `docs:watching`.
   { why: 'configuration key', test: /:$|^[a-z]+:[a-z]/ },
   { why: 'Cabal project file', test: /^cabal\.project$/ },
+  // A CPAN distribution's changelog, named in prose as a file.
+  { why: 'CPAN changelog file', test: /^Changes$/ },
+  // A versioned wire format: `libtmux.where/v1`.
+  { why: 'wire format name', test: /\/v\d+$/ },
+  // A query path with an operator segment: `pane.where.width.-gte`.
+  { why: 'query path', test: /\.-\w/ },
   // A fragment beginning with the separator — `.filter()`, `.gt(...)` — names
   // a method without its receiver, so there is nothing to resolve against.
   { why: 'method without a receiver', test: /^[.:]/ },
diff --git a/packages/api-model/src/resolver.ts b/packages/api-model/src/resolver.ts
index 6dadb3973..f09ca6817 100644
--- a/packages/api-model/src/resolver.ts
+++ b/packages/api-model/src/resolver.ts
@@ -78,6 +78,7 @@ export const DEFAULT_PRIMARY_MODULES: Record<string, string> = {
   elixir: 'LibTmux',
   perl: 'LibTmux',
   lisp: 'libtmux',
+  raku: 'LibTmux',
 }
 
 export const DEFAULT_TEMPLATES: UrlTemplate[] = [
diff --git a/packages/api-model/test/inventory-sphinx.outer.test.ts b/packages/api-model/test/inventory-sphinx.outer.test.ts
index 81a4aa965..d28ffa365 100644
--- a/packages/api-model/test/inventory-sphinx.outer.test.ts
+++ b/packages/api-model/test/inventory-sphinx.outer.test.ts
@@ -10,7 +10,7 @@ import type { ApiModel } from '../src/model.ts'
 
 const here = dirname(fileURLToPath(import.meta.url))
 const DATA = join(here, '../../../site/src/data/api')
-const PORTS = ['py', 'ruby', 'lua', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'perl'] as const
+const PORTS = ['py', 'ruby', 'lua', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'perl', 'raku'] as const
 const load = (port: string): ApiModel => JSON.parse(readFileSync(join(DATA, `${port}.json`), 'utf8'))
 
 describe('Sphinx itself can read every inventory we write', () => {
diff --git a/packages/api-model/test/mentions.test.ts b/packages/api-model/test/mentions.test.ts
index 1b3b035ec..733d1da09 100644
--- a/packages/api-model/test/mentions.test.ts
+++ b/packages/api-model/test/mentions.test.ts
@@ -126,6 +126,32 @@ describe('spans that are code but not API', () => {
   })
 })
 
+describe('distribution files, wire format names and query paths', () => {
+  it('are not API, so an unresolved one is not reported', () => {
+    expect(notApiReason('Changes')).toBe('CPAN changelog file')
+    expect(notApiReason('libtmux.where/v1')).toBe('wire format name')
+    expect(notApiReason('pane.where.width.-gte')).toBe('query path')
+    // The controls: a type, a qualified name and a field path stay candidates.
+    for (const text of ['ChangeSet', 'Changes.parse', 'libtmux.where', 'pane.where.width', 'Mod.fun/1']) {
+      expect(notApiReason(text), text).toBeUndefined()
+    }
+  })
+})
+
+describe('a Raku core type', () => {
+  const raku = { port: 'raku', version: '0', symbols: [{ id: 'LibTmux::Server', name: 'Server', kind: 'class', signatures: [], docs: [] }] }
+  const models = { raku } as unknown as Record<string, ApiModel>
+  const resolver = new Resolver(Object.values(models))
+  const read = (body: string) => pageMentions({
+    body, portByLabel: { Raku: 'raku' }, page: '/raku/latest/guides/getting-started/', authoredPort: 'raku', nativeTmux: false, resolver, models, authoredTarget: () => undefined,
+  })
+
+  it('links to the Raku documentation, and an undefined name is still reported', () => {
+    const page = read('Asynchronous operations return `Promise` values through a `Supply`, unlike `MissingApi`.')
+    expect(page.dangling.map(({ text }) => text)).toEqual(['MissingApi'])
+  })
+})
+
 describe('the assertion helper of an example program', () => {
   it('is a fixture, whichever member is named', () => {
     for (const text of ['Example', 'Example()', 'Example.check', 'Example.check_all', 'Example.ready?']) {
diff --git a/packages/api-model/test/nav-sidecar.test.ts b/packages/api-model/test/nav-sidecar.test.ts
index a9815b386..729b6ebdb 100644
--- a/packages/api-model/test/nav-sidecar.test.ts
+++ b/packages/api-model/test/nav-sidecar.test.ts
@@ -166,6 +166,21 @@ describe('native export groups', () => {
     expect(actual.diagnostics.unmatched).toEqual([])
   })
 
+  it('places a nested exported module in its own module bucket exactly once', () => {
+    const model = fixture()
+    model.symbols.push(
+      { ...symbol('Module.Z.Inner', 'module', 'Module.Z'), apiScope: 'exported' },
+      { ...symbol('Module.Z.Inner.value', 'function', 'Module.Z.Inner'), apiScope: 'exported' },
+    )
+    model.exportGroups![0].members.push('Module.Z.Inner')
+    model.exportGroups!.push({ owner: 'Module.Z.Inner', title: 'Values', members: ['Module.Z.Inner.value'] })
+    const before = structuredClone(model)
+    const actual = navSidecar(GROUPS_ONLY, model)!
+    expect(actual.diagnostics).toEqual({ unmatched: [], deadBuckets: [], ambiguous: [], staleUnsettled: [] })
+    expect(actual.assignments['exports:Module.Z.Inner'].map((entry) => entry.id)).toEqual(['Module.Z.Inner'])
+    expect(model).toEqual(before)
+  })
+
   it.each([
     ['missing direct declaration', (model: ApiModel) => model.exportGroups![1].members.pop()],
     ['duplicate declaration', (model: ApiModel) => model.exportGroups![1].members.push('Module.Z#v:z')],
diff --git a/packages/api-model/test/raku.test.ts b/packages/api-model/test/raku.test.ts
new file mode 100644
index 000000000..b994ab942
--- /dev/null
+++ b/packages/api-model/test/raku.test.ts
@@ -0,0 +1,74 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+import { extractRakuArtifact } from '../src/languages/raku.ts'
+import { sourceUrl } from '../src/products.ts'
+import { SymbolIndex } from '../src/reference.ts'
+
+const revision = 'a'.repeat(40)
+const source = 'unit module LibTmux;\nclass Pane { method inspect(--> Pane:D) {} }\n'
+const file = 'lib/LibTmux.rakumod'
+const hash = createHash('sha256').update(source).digest('hex')
+
+function artifact() {
+  const common = { apiScope: 'exported', product: 'core', package: 'LibTmux', modifiers: [],
+    source: { file, line: 2, revision } }
+  return {
+    schema: 'libtmux.raku-api/v1', port: 'raku', repo: 'libtmux/libtmux-raku', revision,
+    workingTree: false, compiler: 'v2026.09', language: '6.d', extractor: 'Rakudo RakuAST and RakuDoc/v1',
+    aliases: { Pane: 'LibTmux::Pane' }, missingDocumentation: {},
+    generatedSources: { [file]: source },
+    nativeProvenance: { files: [{ path: file, sha256: hash }],
+      library: { repository: 'libtmux/libtmux-raku', revision, workingTree: false }, exporter: {
+      name: 'RakuAST and RakuDoc export', version: 1, repository: 'libtmux/libtmux-raku',
+      revision: 'b'.repeat(40), path: 'tools/export-docs.raku', sha256: 'c'.repeat(64), workingTree: false,
+    } },
+    symbols: [
+      { ...common, id: 'LibTmux', publicId: 'LibTmux', name: 'LibTmux', kind: 'module', signatures: [] },
+      { ...common, id: 'LibTmux::Pane', publicId: 'LibTmux::Pane', name: 'Pane', kind: 'class', parent: 'LibTmux', signatures: [] },
+      { ...common, id: 'LibTmux::Pane.inspect', publicId: 'LibTmux::Pane.inspect', name: 'inspect', kind: 'method', parent: 'LibTmux::Pane',
+        doc: { summary: 'Acquire a [pane](rakudoc:Pane).' },
+        signatures: [{ raw: 'method inspect(--> Pane:D)', params: [], references: [{ start: 19, end: 25, target: 'LibTmux::Pane' }] }] },
+    ],
+  }
+}
+
+describe('native Raku documentation', () => {
+  it('retains compiler signatures, links and exact source provenance', () => {
+    const input = artifact()
+    const model = extractRakuArtifact(input, revision)
+    const method = model.symbols[2]!
+    expect(method.signatures[0]!.raw).toBe('method inspect(--> Pane:D)')
+    expect(method.signatures[0]!.nativeSyntax).toEqual([{ start: 7, end: 14, kind: 'name' }])
+    expect(method.signatures[0]!.nativeSpans!.map((span) => span.text).join('')).toBe(method.signatures[0]!.raw)
+    expect(method.signatures[0]!.nativeSpans!.filter((span) => span.target).map((span) => span.target)).toEqual(['LibTmux::Pane'])
+    expect(method.doc?.summary).toBe('Acquire a :obj:`pane <LibTmux::Pane>`.')
+    const index = new SymbolIndex(model.symbols, (symbol) => `/reference/${symbol.id}/`, 'raku')
+    const prose = index.docSpans(method.doc!.summary!, method)
+    expect(prose.map((span) => 'text' in span ? span.text : 'label' in span ? span.label : '').join(''))
+      .toBe('Acquire a pane.')
+    expect(prose).toContainEqual(expect.objectContaining({ kind: 'ref', label: 'pane',
+      link: expect.objectContaining({ href: '/reference/LibTmux::Pane/' }) }))
+    expect(index.docSpans('`LibTmux::Pane`', method)).toEqual([{ kind: 'code', text: 'LibTmux::Pane' }])
+    expect(model.generatedSources).toBeUndefined()
+    expect(sourceUrl(model, method, '/reference/')).toBe(`https://github.com/libtmux/libtmux-raku/blob/${revision}/${file}#L2`)
+    expect(model.nativeProvenance?.exporter.revision).not.toBe(model.revision)
+    expect(model.nativeProvenance?.exporter.compiler).toBe('2026.09')
+    expect(input.symbols[2]!.doc?.summary).toContain('rakudoc:')
+  })
+
+  it('refuses uncommitted inputs, altered sources and unresolved native links', () => {
+    const dirty = artifact(); dirty.workingTree = true; dirty.nativeProvenance.library.workingTree = true
+    expect(() => extractRakuArtifact(dirty, revision)).toThrow(/uncommitted/)
+    const exporter = artifact(); exporter.nativeProvenance.exporter.workingTree = true
+    expect(() => extractRakuArtifact(exporter, revision)).toThrow(/uncommitted/)
+    expect(() => extractRakuArtifact(artifact(), 'd'.repeat(40))).toThrow(/revision mismatch/)
+    const altered = artifact(); altered.generatedSources[file] += '# changed\n'
+    expect(() => extractRakuArtifact(altered, revision)).toThrow(/digest/)
+    const escaped = artifact(); escaped.nativeProvenance.files[0]!.path = '../outside'
+    expect(() => extractRakuArtifact(escaped, revision)).toThrow(/source path/)
+    const missing = artifact(); missing.symbols[2]!.doc!.summary = '[bad](rakudoc:Missing)'
+    expect(() => extractRakuArtifact(missing, revision)).toThrow(/unresolved/)
+    const invalid = artifact(); invalid.symbols[2]!.signatures[0]!.references[0]!.end = 999
+    expect(() => extractRakuArtifact(invalid, revision)).toThrow(/type reference/)
+  })
+})
diff --git a/scripts/README.md b/scripts/README.md
index 8363aaacf..adba1e3f7 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -581,8 +581,15 @@ send an install command to nothing. A baseline tag the repository does not
 carry is dropped, so a port with no release tag records none and installs from
 its default branch.
 
+A git tag is not a release for a port whose core package the inventory does not
+mark `published`: the resolver writes an unpublished entry for it as
+`maturity: "unreleased"`, whatever tag the repository carries, including an
+entry it keeps from the baseline after a failed probe. Swift and C++ resolve
+releases from tags, are `published` in the inventory, and keep the stage their
+tag names.
+
 `gen-registry.negative.mjs` resolves each state Julia can be in, including a
-final tag that General does not carry yet, and requires every badge to read the
+final tag that General does not carry, and requires every badge to read the
 result. A build fails on an entry its badges cannot read, and only the deploy
 resolves live tags, so a pull request meets that failure here.
 
@@ -592,6 +599,29 @@ path (`mcp/v0.0.1-alpha.9`) while the library tags bare. `tagPrefix` in
 ports.ts declares the first case, and its absence rejects any tag carrying `/`
 or `@`, so a submodule's release is never read as the library's.
 
+```console
+$ node scripts/gen-perl-pod.mjs
+```
+
+Regenerates `site/src/data/perl-pod.json`, which records what the latest CPAN
+release of each Perl distribution documents: the document each provided
+package belongs to, each document's file with its SHA-256, and the fragments of
+its rendered POD. A Perl reference page builds its MetaCPAN POD links from it
+and the API model alone, so rendering and the unit tests request nothing. MetaCPAN
+answers a script's page request with a challenge, so the script reads
+`fastapi.metacpan.org` instead: the `pod` endpoint renders a page's body with
+the page's own renderer, which makes a heading's `id` the fragment the page
+answers to, and the `source` endpoint gives the file whose digest is compared
+with the one the API model recorded. It refuses a distribution that is not the
+latest released one, a package MetaCPAN files under another release, and a POD
+whose NAME section names another module.
+
+The distributions are the Perl port's packages in `ports.ts`. Pass `--check` to
+fail instead of writing when the file differs from what MetaCPAN reports now,
+and `--offline` with it to read the committed file alone, as the test gate does.
+`gen-perl-pod.negative.mjs` shows the offline check failing on each defect a link
+depends on.
+
 Assemble a complete preview:
 
 ```console
diff --git a/scripts/build-site.sh b/scripts/build-site.sh
index d60c9f859..5b5ed4a3b 100755
--- a/scripts/build-site.sh
+++ b/scripts/build-site.sh
@@ -303,7 +303,8 @@ if [ -n "${LIBTMUX_DOCS_PORT:-}" ] && { [ "$LIBTMUX_DOCS_PORT" = ruby ] || [ "$L
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT"
   node "$script_dir/stage-port-docs.mjs" --port "$LIBTMUX_DOCS_PORT"
 elif [ -n "${LIBTMUX_DOCS_SOURCE_SHA:-}" ] && { [ "$LIBTMUX_DOCS_PORT" = powershell ] || [ "$LIBTMUX_DOCS_PORT" = julia ] ||
-  [ "$LIBTMUX_DOCS_PORT" = elixir ] || [ "$LIBTMUX_DOCS_PORT" = ocaml ] || [ "$LIBTMUX_DOCS_PORT" = haskell ] || [ "$LIBTMUX_DOCS_PORT" = perl ] || [ "$LIBTMUX_DOCS_PORT" = lisp ] || [ "$LIBTMUX_DOCS_PORT" = erlang ]; }; then
+  [ "$LIBTMUX_DOCS_PORT" = elixir ] || [ "$LIBTMUX_DOCS_PORT" = ocaml ] || [ "$LIBTMUX_DOCS_PORT" = haskell ] || [ "$LIBTMUX_DOCS_PORT" = perl ] || [ "$LIBTMUX_DOCS_PORT" = lisp ] || [ "$LIBTMUX_DOCS_PORT" = erlang ] ||
+  [ "$LIBTMUX_DOCS_PORT" = raku ]; }; then
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT"
   node "$script_dir/stage-port-docs.mjs" --port "$LIBTMUX_DOCS_PORT" --from-source
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT" --nav
diff --git a/scripts/gen-api-model.mjs b/scripts/gen-api-model.mjs
index 6d71b5265..42b329c01 100644
--- a/scripts/gen-api-model.mjs
+++ b/scripts/gen-api-model.mjs
@@ -16,6 +16,7 @@ import { PORTS as PORT_DEFS } from '../site/src/lib/ports.ts'
 import { extractDoxygen } from '../packages/api-model/src/languages/doxygen.ts'
 import { extractLua } from '../packages/api-model/src/languages/lua.ts'
 import { extractPerlArtifact } from '../packages/api-model/src/languages/perl.ts'
+import { extractRakuArtifact } from '../packages/api-model/src/languages/raku.ts'
 import { extractRuby } from '../packages/api-model/src/languages/ruby.ts'
 import { extractPowerShell } from '../packages/api-model/src/languages/powershell.ts'
 import { extractJulia } from '../packages/api-model/src/languages/julia.ts'
@@ -235,6 +236,10 @@ const PORTS = {
     checkout: '~/work/libtmux/libtmux-perl-docs-site', root: '.', nativeArtifact: 'docs/_build/api.json',
     repo: 'libtmux/libtmux-perl', options: {},
   },
+  raku: {
+    checkout: '~/work/libtmux/libtmux-raku-docs-site', root: '.', nativeArtifact: 'docs/_build/api.json',
+    repo: 'libtmux/libtmux-raku', options: {},
+  },
   ruby: {
     checkout: '~/work/libtmux/libtmux-ruby-docs',
     root: '.',
@@ -689,8 +694,18 @@ for (const [port, cfg] of Object.entries(PORTS)) {
       process.exit(1)
     }
     const artifact = JSON.parse(readFileSync(artifactPath, 'utf8'))
-    const nativeExtractors = { perl: extractPerlArtifact, ruby: extractRuby, lua: extractLua, powershell: extractPowerShell, julia: extractJulia, elixir: extractElixir, ocaml: extractOcamlArtifact, haskell: extractHaskellArtifact, clojure: extractClojure, lisp: extractCommonLisp, erlang: extractErlang }
+    const nativeExtractors = { raku: extractRakuArtifact, perl: extractPerlArtifact, ruby: extractRuby, lua: extractLua, powershell: extractPowerShell, julia: extractJulia, elixir: extractElixir, ocaml: extractOcamlArtifact, haskell: extractHaskellArtifact, clojure: extractClojure, lisp: extractCommonLisp, erlang: extractErlang }
     model = nativeExtractors[port](artifact, head)
+    if (port === 'raku') {
+      // The exporter runs in the library checkout, so its bytes and compiler are part of what the model claims.
+      const producer = model.nativeProvenance.exporter
+      const pin = git(checkout, 'show', `${head}:.tool-versions`)?.split('\n').includes(`raku ${producer.compiler}`)
+      if (!pin) throw new Error('gen-api-model: raku native artifact compiler differs from the .tool-versions pin')
+      const exporterBytes = execFileSync('git', ['-C', checkout, 'show', `${head}:${producer.path}`], { maxBuffer: 1 << 26 })
+      if (createHash('sha256').update(exporterBytes).digest('hex') !== producer.sha256) {
+        throw new Error('gen-api-model: raku native artifact uses different exporter bytes')
+      }
+    }
     if (port === 'haskell') {
       const verify = (root, sourceRevision, input) => {
         const bytes = execFileSync('git', ['-C', root, 'show', `${sourceRevision}:${input.path}`], {
diff --git a/scripts/gen-core-recording.mjs b/scripts/gen-core-recording.mjs
index 84ae44eeb..4c1171c16 100644
--- a/scripts/gen-core-recording.mjs
+++ b/scripts/gen-core-recording.mjs
@@ -88,7 +88,7 @@ const read = readTmuxState({ sandbox: sandboxReal })
 function prepare() {
   for (const name of ['home', 'config', 'bin', 'exact', 'marked']) mkdirSync(join(sandbox, name), { recursive: true })
   const entry = join(root, 'scripts/core-trace.mjs')
-  writeFileSync(join(sandbox, 'bin/tmux'), shimScript({ node: process.execPath, entry }))
+  writeFileSync(join(sandbox, 'bin/tmux'), shimScript({ node: process.execPath, entry, inPlace: recipe.inPlace }))
   writeFileSync(join(sandbox, 'bin/docs-mark'), `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(entry)} mark "$@"\n`)
   for (const name of ['tmux', 'docs-mark']) chmodSync(join(sandbox, 'bin', name), 0o755)
   const marked = recipe.instrument(program.code, recipe.steps)
diff --git a/scripts/gen-perl-pod.mjs b/scripts/gen-perl-pod.mjs
new file mode 100644
index 000000000..86b54679f
--- /dev/null
+++ b/scripts/gen-perl-pod.mjs
@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * What each Perl distribution's latest CPAN release documents, for the links
+ * from a reference page to its POD on MetaCPAN.
+ *
+ * A reference page for `LibTmux::Server->new` may link to the method's POD
+ * section only if that section exists in a release. MetaCPAN's pages cannot be
+ * requested by a script, so this reads its API instead (see `lib/perl-pod.mjs`)
+ * and records, per distribution, the release, the document that each provided
+ * package belongs to, and for each document its file's SHA-256 and the
+ * fragments of its rendered POD. `site/src/data/perl-pod.json` is the result.
+ * A page's link is built from it offline, and shown only for source whose
+ * SHA-256 matches the release's, or labelled with the release where it does
+ * not.
+ *
+ * The distributions are the Perl port's packages in `site/src/lib/ports.ts`,
+ * so a package added there is recorded, or reported as missing, without
+ * another list to edit. Nothing in the file depends on when it was written, so
+ * `--check` fails only when MetaCPAN's latest release changed.
+ *
+ * Usage:
+ *   node scripts/gen-perl-pod.mjs [--out <path>] [--check] [--offline]
+ *
+ *   --out <path>  Write there (default: site/src/data/perl-pod.json).
+ *   --check       Write nothing; exit 1 if the file differs from what MetaCPAN reports now.
+ *   --offline     With --check, request nothing: read the file and report what is wrong with it.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { PORTS } from '../site/src/lib/ports.ts'
+import { SCHEMA, observeDistribution, problemsWith } from './lib/perl-pod.mjs'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const DEFAULT_OUT = join(root, 'site', 'src', 'data', 'perl-pod.json')
+const USER_AGENT = 'libtmux-docs gen-perl-pod.mjs'
+
+function parseArgs(argv) {
+  const opts = { out: DEFAULT_OUT, check: false, offline: false }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--out') opts.out = argv[++i]
+    else if (arg === '--check') opts.check = true
+    else if (arg === '--offline') opts.offline = true
+    else if (arg === '-h' || arg === '--help') opts.help = true
+    else throw new Error(`unrecognised argument: ${arg}`)
+  }
+  return opts
+}
+
+const opts = parseArgs(process.argv.slice(2))
+if (opts.help) {
+  console.log(readFileSync(fileURLToPath(import.meta.url), 'utf8').split('*/')[0])
+  process.exit(0)
+}
+if (opts.offline && !opts.check) throw new Error('--offline only applies to --check')
+
+const dists = PORTS.find((port) => port.slug === 'perl').packages.map((entry) => entry.name)
+const read = (path) => (existsSync(path) ? readFileSync(path, 'utf8') : '')
+
+if (opts.check && opts.offline) {
+  const text = read(opts.out)
+  const data = text ? JSON.parse(text) : undefined
+  const problems = data ? problemsWith(data, dists) : [`${opts.out} does not exist`]
+  if (data && `${JSON.stringify(data, null, 2)}\n` !== text) problems.push('the file is not what the generator writes byte for byte')
+  for (const problem of problems) console.error(`  ${problem}`)
+  if (problems.length > 0) {
+    console.error(`${problems.length} problem${problems.length === 1 ? '' : 's'} in ${opts.out}. Run: node scripts/gen-perl-pod.mjs`)
+    process.exit(1)
+  }
+  console.log(`${opts.out} is well formed`)
+  process.exit(0)
+}
+
+let last = 0
+/** One GET with a pause between requests, so a run is polite to the API; a 5xx or a dropped request is tried again. */
+async function get(url) {
+  for (let attempt = 0; ; attempt += 1) {
+    const wait = last + 150 - Date.now()
+    if (wait > 0) await new Promise((resolveWait) => setTimeout(resolveWait, wait))
+    last = Date.now()
+    try {
+      const response = await fetch(url, { headers: { 'user-agent': USER_AGENT }, signal: AbortSignal.timeout(30_000) })
+      const bytes = Buffer.from(await response.arrayBuffer())
+      if (response.status >= 500 && attempt < 3) throw new Error(`HTTP ${response.status}`)
+      return { status: response.status, bytes, text: bytes.toString('utf8') }
+    } catch (error) {
+      if (attempt >= 3) throw error
+      await new Promise((resolveWait) => setTimeout(resolveWait, 1000 * (attempt + 1)))
+    }
+  }
+}
+
+const distributions = {}
+for (const dist of dists) distributions[dist] = await observeDistribution(get, dist)
+const payload = { schema: SCHEMA, distributions }
+const problems = problemsWith(payload, dists)
+if (problems.length > 0) {
+  for (const problem of problems) console.error(`  ${problem}`)
+  throw new Error('MetaCPAN reported a release this file cannot hold')
+}
+const text = `${JSON.stringify(payload, null, 2)}\n`
+
+if (opts.check) {
+  if (read(opts.out) !== text) {
+    console.error(`${opts.out} is out of date. Run: node scripts/gen-perl-pod.mjs`)
+    for (const [dist, release] of Object.entries(distributions)) {
+      const before = JSON.parse(read(opts.out) || '{"distributions":{}}').distributions[dist]
+      if (JSON.stringify(before) !== JSON.stringify(release)) console.error(`  ${dist}: ${before?.release ?? 'none'} -> ${release.release}`)
+    }
+    process.exit(1)
+  }
+  console.log(`${opts.out} is current`)
+} else {
+  writeFileSync(opts.out, text)
+  console.log(`wrote ${opts.out}`)
+  for (const [dist, release] of Object.entries(distributions)) {
+    console.log(`  ${dist.padEnd(18)} ${release.release} ${Object.keys(release.documents).length} documents, ${Object.keys(release.packages).length} packages`)
+  }
+}
diff --git a/scripts/gen-perl-pod.negative.mjs b/scripts/gen-perl-pod.negative.mjs
new file mode 100644
index 000000000..1e1a5f03a
--- /dev/null
+++ b/scripts/gen-perl-pod.negative.mjs
@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/*
+ * Proof that `gen-perl-pod.mjs --check --offline` can still fail.
+ *
+ * Offline, the check reads the committed record and reports what a link could
+ * not be built from. A check that passed any file would pass the control too,
+ * so the control is a copy of the committed record and each case edits its own
+ * copy: a distribution dropped, a digest that is not one, a package that names
+ * a document the record lacks, a fragment listed twice, a release written in
+ * another grammar, and a file that is not what the generator writes byte for
+ * byte. None of them reaches the network.
+ */
+import { copyFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const script = join(here, 'gen-perl-pod.mjs')
+const real = join(here, '..', 'site/src/data/perl-pod.json')
+
+function run(file) {
+  try {
+    return { code: 0, out: execFileSync('node', [script, '--check', '--offline', '--out', file], { encoding: 'utf8', stdio: 'pipe' }) }
+  } catch (err) {
+    return { code: err.status, out: `${err.stdout ?? ''}${err.stderr ?? ''}` }
+  }
+}
+
+let failures = 0
+const check = (name, ok, detail) => {
+  if (ok) console.log(`ok   ${name}`)
+  else {
+    console.error(`FAIL ${name} - ${detail}`)
+    failures += 1
+  }
+}
+const edited = (change) => `${JSON.stringify(change(JSON.parse(readFileSync(real, 'utf8'))), null, 2)}\n`
+
+{
+  const dir = mkdtempSync(join(tmpdir(), 'gen-perl-pod-'))
+  const file = join(dir, 'perl-pod.json')
+  copyFileSync(real, file)
+  const res = run(file)
+  check('the committed record passes', res.code === 0 && /is well formed/.test(res.out), `exit ${res.code}: ${res.out.trim()}`)
+  rmSync(dir, { recursive: true, force: true })
+}
+
+const mutations = [
+  ['a dropped distribution is caught', edited((data) => { delete data.distributions['LibTmux-Async']; return data }), /LibTmux-Async has no recorded release/],
+  ['a record for a distribution the port lacks is caught', edited((data) => { data.distributions['LibTmux-Mcp'] = data.distributions.LibTmux; return data }), /LibTmux-Mcp is recorded but not a package of the port/],
+  ['a digest that is not a SHA-256 is caught', edited((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].sha256 = 'abc'; return data }), /LibTmux::Server has no SHA-256/],
+  ['a package that names a document the record lacks is caught', edited((data) => { data.distributions.LibTmux.packages['LibTmux::Server'] = 'LibTmux::Missing'; return data }), /documented by LibTmux::Missing, which the record lacks/],
+  ['a fragment listed twice is caught', edited((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].anchors.push('new'); return data }), /lists its fragments wrongly/],
+  ['a release in another grammar is caught', edited((data) => { data.distributions.LibTmux.release = '0.0.3'; return data }), /release "0\.0\.3" is not a decimal version/],
+  ['another schema is caught', edited((data) => ({ ...data, schema: 2 })), /schema is 2, expected 1/],
+  ['a file the generator would not write is caught', `${JSON.stringify(JSON.parse(readFileSync(real, 'utf8')))}\n`, /not what the generator writes byte for byte/],
+]
+
+for (const [name, text, pattern] of mutations) {
+  const dir = mkdtempSync(join(tmpdir(), 'gen-perl-pod-'))
+  const file = join(dir, 'perl-pod.json')
+  writeFileSync(file, text)
+  const res = run(file)
+  check(name, res.code === 1 && pattern.test(res.out), `exit ${res.code}: ${res.out.trim()}`)
+  rmSync(dir, { recursive: true, force: true })
+}
+
+if (failures) {
+  console.error(`\ngen-perl-pod.negative: ${failures} case(s) did not behave as required.`)
+  process.exit(1)
+}
+console.log('gen-perl-pod.negative: the offline record check can fail')
diff --git a/scripts/gen-registry.mjs b/scripts/gen-registry.mjs
index 70cb700fb..4183bdf34 100644
--- a/scripts/gen-registry.mjs
+++ b/scripts/gen-registry.mjs
@@ -29,6 +29,13 @@
  * rather than in a hand-typed string that goes stale the next time anyone
  * publishes. `ports.ts` owns the spellings; this owns the state.
  *
+ * A git tag is not a release. A port whose core package the inventory
+ * (`site/src/lib/port-inventory.ts`) does not mark `published` installs from
+ * source, so an unpublished entry for it is written `maturity: "unreleased"`
+ * whatever tag the repository carries, and every badge, notice and prompt reads
+ * it as unreleased. Swift and C++ are `published`: SwiftPM and their own vcpkg
+ * registry resolve a release from its tag, so the tag still names their stage.
+ *
  * Offline, or behind a rate limit, every probe falls back to the committed
  * file rather than writing a worse one. Same discipline as gen-versions.mjs's
  * seed: a build with no network reproduces the last known-good answer instead
@@ -58,6 +65,7 @@ const siteLib = join(repoRoot, 'site', 'src', 'lib')
 const DEFAULT_OUT = join(repoRoot, 'site', 'src', 'data', 'registry.json')
 
 const { PORTS } = await import(`file://${join(siteLib, 'ports.ts')}`)
+const { INVENTORY } = await import(`file://${join(siteLib, 'port-inventory.ts')}`)
 const { comparePackageVersions, newestPublishedTag, packageVersionIsPrerelease, parseTag, releaseTag } = await import(
   `file://${join(siteLib, 'versions.ts')}`
 )
@@ -294,11 +302,50 @@ const PROBES = {
     const retired = new Set(Object.keys(body.retirements ?? {}))
     return (body.releases ?? []).map((release) => release.version).filter((version) => !retired.has(version))
   },
+  async perl() {
+    // MetaCPAN's API lists every release of a distribution with the maturity and status PAUSE gave it. A developer
+    // release (`0.001_001`) is not indexed and BackPAN holds removed ones, so neither is installable.
+    // A Perl version is a decimal number, which no SemVer grammar here reads, so the versions come back sorted
+    // newest first and the tag is matched against the registry's own text, as `v` and that text.
+    const packages = {}
+    for (const name of ['LibTmux', 'LibTmux-Async', 'LibTmux-Workspace']) {
+      const { status, body } = await getJson(`https://fastapi.metacpan.org/v1/release/_search?q=distribution:${name}&size=100`)
+      if (status !== 200 || !Array.isArray(body?.hits?.hits)) throw new Error(`MetaCPAN ${name}: HTTP ${status}`)
+      const releases = body.hits.hits.map((hit) => hit._source)
+      if (releases.some((release) => typeof release?.distribution !== 'string' || !/^\d+\.\d+(?:_\d+)?$/.test(release.version ?? ''))) {
+        throw new Error(`MetaCPAN ${name}: invalid release`)
+      }
+      const installable = releases.filter((release) => release.distribution === name && release.maturity === 'released'
+        && release.status !== 'backpan' && release.authorized !== false)
+      packages[name] = installable.length > 0 ? installable.map((release) => release.version).sort((a, b) => Number(b) - Number(a)) : null
+    }
+    const decimalTag = (tags, versions) => versions?.map((version) => `v${version}`).find((name) => tags.includes(name)) ?? null
+    return { versions: packages.LibTmux, packages, tagFor: decimalTag }
+  },
   async lisp() {
     // This port is source-installed through ASDF and Qlot. It deliberately
     // has no central package-registry entry to probe.
     return null
   },
+  async raku(port) {
+    // zef reads one ecosystem index, so the index is the registry. Raku Land renders the same
+    // entries, but its pages carry no machine-readable listing. The authority is part of a
+    // distribution's identity; another publisher's LibTmux is not this package.
+    const response = await fetch('https://360.zef.pm/index.json', {
+      headers: { 'user-agent': 'libtmux-docs gen-registry.mjs' },
+      signal: AbortSignal.timeout(90_000),
+    })
+    if (!response.ok) throw new Error(`Raku ecosystem index: HTTP ${response.status}`)
+    const index = await response.json()
+    if (!Array.isArray(index)) throw new Error('Invalid Raku ecosystem index')
+    const versions = index
+      .filter((entry) => entry?.name === port.packageName && entry.auth === 'zef:libtmux')
+      .map((entry) => entry.version)
+    if (versions.some((version) => typeof version !== 'string' || !releaseTag(`v${version}`, port))) {
+      throw new Error('Unsupported Raku distribution version')
+    }
+    return versions.length > 0 ? versions : null
+  },
   async ts() {
     // `libtmux`, not the scoped `@libtmux/libtmux` this probe used to ask for.
     // The scoped name 404s, which classified a published package as having
@@ -497,7 +544,8 @@ for (const port of PORTS) {
   // need the name that exists in the repository. Only a published version's
   // tag counts, so a release caught between its tag and its package is not
   // recorded until the package lands.
-  let tag = newestPublishedTag(tags, port, versions)
+  const tagFor = (list) => (probe && !Array.isArray(probe) && probe.tagFor ? probe.tagFor(tags, list) : newestPublishedTag(tags, port, list))
+  let tag = tagFor(versions)
   if (!tag) {
     // A tag recorded before its package landed stays. One the repository does
     // not carry is stale, and would send readers to a ref that does not exist.
@@ -513,13 +561,24 @@ for (const port of PORTS) {
     entry.packages = Object.fromEntries(
       Object.entries(probe.packages).map(([name, packageVersions]) => [
         name,
-        withStage(classify(port, packageVersions, probe.tagged && !probe.tagged.includes(name) ? null : tag), name),
+        withStage(classify(port, packageVersions, probe.tagFor ? tagFor(packageVersions) : probe.tagged && !probe.tagged.includes(name) ? null : tag), name),
       ]),
     )
   }
   ports[port.slug] = entry
 }
 
+/*
+ * Applied to every entry, including one kept from the baseline after a failed
+ * probe, so a stale copy cannot reintroduce a release the port does not have.
+ */
+for (const [slug, entry] of Object.entries(ports)) {
+  const core = INVENTORY[slug]?.find((candidate) => candidate.kind === 'library')
+  if (entry.status !== 'unpublished' || !core || core.status === 'published') continue
+  const { packages, ...rest } = entry
+  ports[slug] = { ...rest, maturity: 'unreleased', ...(packages && { packages }) }
+}
+
 const payload = {
   schema: SCHEMA,
   /**
diff --git a/scripts/gen-registry.negative.mjs b/scripts/gen-registry.negative.mjs
index d5f9034fd..4641e1c14 100644
--- a/scripts/gen-registry.negative.mjs
+++ b/scripts/gen-registry.negative.mjs
@@ -87,11 +87,14 @@ for (const [name, mutate] of mutations) {
     copyFileSync(script, join(dir, 'scripts/gen-registry.mjs'))
     copyFileSync(join(here, 'lib/port-checkout.mjs'), join(dir, 'scripts/lib/port-checkout.mjs'))
     copyFileSync(join(here, '../site/src/lib/versions.ts'), join(dir, 'site/src/lib/versions.ts'))
+    copyFileSync(join(here, '../site/src/lib/port-inventory.ts'), join(dir, 'site/src/lib/port-inventory.ts'))
     copyFileSync(real, join(dir, 'site/src/data/registry.json'))
     const ports = PORTS.map(({ slug, repo, packageName, tagGrammar, tagPrefix, registry }) => ({
       slug, repo, packageName, tagGrammar, tagPrefix, registry, checkout: join(dir, 'absent', slug),
     }))
-    writeFileSync(join(dir, 'site/src/lib/ports.ts'), `export const PORTS = ${JSON.stringify(ports)}\n`)
+    // A port with no registry and no probe is the source-only case; `extra` adds one for the checks that need it.
+    const useStub = (extra = []) => writeFileSync(join(dir, 'site/src/lib/ports.ts'), `export const PORTS = ${JSON.stringify([...ports, ...extra])}\n`)
+    useStub()
     const seed = JSON.parse(readFileSync(real, 'utf8'))
     const baseline = structuredClone(seed)
     delete baseline.ports.powershell
@@ -159,21 +162,76 @@ for (const [name, mutate] of mutations) {
     const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
     let result = invoke(replies)
     check('an older published registry gains both ports', Object.keys(result.ports).length === PORTS.length, result.error)
-    check('source-only Perl keeps its unpublished package entries during online refresh',
-      same(result.ports.perl, seed.ports.perl), result.error)
-    writeFileSync(join(dir, 'published.json'), JSON.stringify({
-      ...baseline, ports: { ...baseline.ports, perl: { status: 'release', version: '1.0.0', release: '1.0.0', tag: 'v1.0.0' } },
-    }))
+    // A source-only port declares no registry and has no probe, so its unpublished entry is kept and a published one is refused.
+    const sourceOnly = { slug: 'sourceonly', repo: 'libtmux/libtmux-sourceonly', packageName: 'sourceonly', tagGrammar: 'semver', checkout: join(dir, 'absent', 'sourceonly') }
+    const unpublished = { status: 'unpublished', version: null, release: null, tag: null }
+    const published = { status: 'release', version: '1.0.0', release: '1.0.0', tag: 'v1.0.0' }
+    useStub([sourceOnly])
+    writeFileSync(join(dir, 'published.json'), JSON.stringify({ ...baseline, ports: { ...baseline.ports, sourceonly: unpublished } }))
+    check('a source-only port keeps its unpublished entry during online refresh',
+      same(invoke(replies).ports.sourceonly, unpublished), invoke(replies).error)
+    writeFileSync(join(dir, 'published.json'), JSON.stringify({ ...baseline, ports: { ...baseline.ports, sourceonly: published } }))
     const unconfigured = invoke(replies)
-    check('a published Perl entry requires a registry probe', /perl: no registry probe/.test(unconfigured.error), unconfigured.error)
+    check('a published entry of a port with no probe requires a registry probe', /sourceonly: no registry probe/.test(unconfigured.error), unconfigured.error)
     writeFileSync(join(dir, 'published.json'), JSON.stringify({
-      ...baseline, ports: { ...baseline.ports, perl: { ...seed.ports.perl, packages: {
-        ...seed.ports.perl.packages, 'LibTmux-Workspace': { status: 'release', version: '1.0.0', release: '1.0.0', tag: 'v1.0.0' },
-      } } },
+      ...baseline, ports: { ...baseline.ports, sourceonly: { ...unpublished, packages: { companion: published } } },
     }))
     const companion = invoke(replies)
-    check('a published Perl companion also requires a registry probe', /perl: no registry probe/.test(companion.error), companion.error)
+    check('a published companion of a port with no probe also requires a registry probe', /sourceonly: no registry probe/.test(companion.error), companion.error)
+    useStub()
     writeFileSync(join(dir, 'published.json'), JSON.stringify(baseline))
+    // The deploy builds from what the resolver wrote, and a badge that cannot read an entry fails that
+    // build after the registry job has passed. Resolve each state Julia can be in, then read every
+    // port's badges and packages from the result. An incomplete result is not a clean read.
+    const unread = (resolved) => {
+      const count = Object.keys(resolved.ports).length
+      if (count !== PORTS.length) return [`the resolver wrote ${count} of ${PORTS.length} ports: ${resolved.error}`]
+      const registry = { schema: 2, ports: resolved.ports }
+      return PORTS.flatMap((port) => [
+        ...['core', 'mcp', 'workspace'].filter((product) => product === 'core' || productAvailable(port, product))
+          .map((product) => [`${port.slug} ${product}`, () => productStatus(port, product, registry)]),
+        ...Object.entries(registry.ports[port.slug].packages ?? {})
+          .map(([name, item]) => [`${port.slug} ${name}`, () => releaseMaturity(item, port.tagGrammar)]),
+      ].flatMap(([label, read]) => {
+        try {
+          read()
+          return []
+        } catch (err) {
+          return [`${label}: ${err.message}`]
+        }
+      }))
+    }
+    const tagged = (...names) => ({ body: JSON.stringify(names.map((name) => ({ name }))) })
+    // CPAN: decimal versions order as numbers, developer and BackPAN releases are not installable, and a tag counts once its release is indexed.
+    const cpanSearch = (dist) => `https://fastapi.metacpan.org/v1/release/_search?q=distribution:${dist}&size=100`
+    const cpanHits = (dist, ...releases) => ({ body: JSON.stringify({ hits: { hits: releases.map(([version, status = 'cpan', maturity = 'released']) => ({
+      _source: { distribution: dist, version, status, maturity, authorized: true },
+    })) } }) })
+    const perlTags = 'https://api.github.com/repos/libtmux/libtmux-perl/tags?per_page=100'
+    const cpan = {
+      ...replies,
+      [perlTags]: tagged('v0.002', 'v0.003', 'v0.010', 'v0.011'),
+      [cpanSearch('LibTmux')]: cpanHits('LibTmux', ['0.002'], ['0.010', 'latest'], ['0.003'], ['0.011_001', 'cpan', 'developer'], ['0.001', 'backpan']),
+      [cpanSearch('LibTmux-Async')]: cpanHits('LibTmux-Async', ['0.002', 'latest']),
+      [cpanSearch('LibTmux-Workspace')]: cpanHits('LibTmux-Workspace'),
+    }
+    result = invoke(cpan)
+    check('CPAN orders decimal versions as numbers and skips developer and BackPAN releases',
+      result.ports.perl?.version === '0.010' && result.ports.perl?.release === '0.010' && result.ports.perl?.status === 'release', `${JSON.stringify(result.ports.perl)} ${result.error}`)
+    check('a CPAN tag is recorded once its release is indexed, and not before',
+      result.ports.perl?.tag === 'v0.010' && result.ports.perl?.packages?.['LibTmux-Async']?.tag === 'v0.002', `${JSON.stringify(result.ports.perl)} ${result.error}`)
+    check('a distribution CPAN does not carry is unpublished beside one it does',
+      same(result.ports.perl?.packages?.['LibTmux-Workspace'], unpublished) && result.ports.perl?.packages?.['LibTmux-Async']?.version === '0.002', `${JSON.stringify(result.ports.perl)} ${result.error}`)
+    check('every badge reads a CPAN release as the 0.x series', unread(result).length === 0
+      && productStatus(PORTS.find(({ slug }) => slug === 'perl'), 'core', { schema: 2, ports: result.ports }) === '0.x', `${JSON.stringify(unread(result))}`)
+    for (const [why, response] of [
+      ['HTTP 500', { status: 500, body: 'unavailable' }],
+      ['an unexpected body', { body: '{"error":"Not found"}' }],
+      ['a release with no decimal version', cpanHits('LibTmux', ['1.2.3'])],
+    ]) {
+      result = invoke({ ...cpan, [cpanSearch('LibTmux')]: response })
+      check(`CPAN ${why} preserves the committed Perl entry`, same(result.ports.perl, seed.ports.perl), `${JSON.stringify(result.ports.perl)} ${result.error}`)
+    }
     check('Gallery pages refresh the core and workspace prereleases, excluding unlisted versions',
       result.ports.powershell?.version === '0.1.0-alpha3' && result.ports.powershell?.tag === 'v0.1.0-alpha3'
       && result.ports.powershell?.packages?.['LibTmux.Workspace']?.version === '0.1.0-alpha4', result.error)
@@ -232,34 +290,12 @@ for (const [name, mutate] of mutations) {
       result.ports.julia?.tag === 'v0.1.0-alpha.1', `${JSON.stringify(result.ports.julia)} ${result.error}`)
     writeFileSync(join(dir, 'published.json'), JSON.stringify(baseline))
 
-    // The deploy builds from what the resolver wrote, and a badge that cannot read an entry fails that
-    // build after the registry job has passed. Resolve each state Julia can be in, then read every
-    // port's badges and packages from the result. An incomplete result is not a clean read.
-    const unread = (resolved) => {
-      const count = Object.keys(resolved.ports).length
-      if (count !== PORTS.length) return [`the resolver wrote ${count} of ${PORTS.length} ports: ${resolved.error}`]
-      const registry = { schema: 2, ports: resolved.ports }
-      return PORTS.flatMap((port) => [
-        ...['core', 'mcp', 'workspace'].filter((product) => product === 'core' || productAvailable(port, product))
-          .map((product) => [`${port.slug} ${product}`, () => productStatus(port, product, registry)]),
-        ...Object.entries(registry.ports[port.slug].packages ?? {})
-          .map(([name, item]) => [`${port.slug} ${name}`, () => releaseMaturity(item, port.tagGrammar)]),
-      ].flatMap(([label, read]) => {
-        try {
-          read()
-          return []
-        } catch (err) {
-          return [`${label}: ${err.message}`]
-        }
-      }))
-    }
     const juliaPort = PORTS.find(({ slug }) => slug === 'julia')
-    const tagged = (...names) => ({ body: JSON.stringify(names.map((name) => ({ name }))) })
     const notInGeneral = { status: 404, body: '404: Not Found' }
     const prereleaseOnly = { body: `["0.1.0-alpha.2"]\ngit-tree-sha1 = "${'c'.repeat(40)}"\n` }
     for (const [state, repository, registry, stage] of [
-      ['a final tag General does not carry yet', ['v0.1.0'], notInGeneral, '0.x'],
-      ['a prerelease tag General does not carry yet', ['v0.1.0-alpha.1'], notInGeneral, 'alpha'],
+      ['a final tag General does not carry yet', ['v0.1.0'], notInGeneral, 'unreleased'],
+      ['a prerelease tag General does not carry yet', ['v0.1.0-alpha.1'], notInGeneral, 'unreleased'],
       ['a prerelease General carries', ['v0.1.0-alpha.2'], prereleaseOnly, 'alpha'],
       ['a prerelease General carries beside a final tag it lacks', ['v0.1.0-alpha.2', 'v0.1.0'], prereleaseOnly, 'alpha'],
       ['no tag and no General package', [], notInGeneral, 'unreleased'],
@@ -270,17 +306,33 @@ for (const [name, mutate] of mutations) {
       check(`every badge reads ${state} as ${stage}`, read === stage, `${read} ${JSON.stringify(failures)}`)
     }
     result = invoke({ ...replies, [julia]: tagged('v0.1.0'), [general]: notInGeneral })
-    check('a final tag General does not carry yet is recorded as the live registry recorded it',
-      same(result.ports.julia, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }), `${JSON.stringify(result.ports.julia)} ${result.error}`)
+    check('a final tag General does not carry yet is recorded as unreleased',
+      same(result.ports.julia, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }), `${JSON.stringify(result.ports.julia)} ${result.error}`)
+    // The gate follows the inventory, not the port: Swift and C++ are published there, so their tags still name a stage.
+    const cxxTags = 'https://api.github.com/repos/libtmux/libtmux-cxx/tags?per_page=100'
+    const vcpkg = 'https://raw.githubusercontent.com/microsoft/vcpkg/master/ports/libtmux-cxx/vcpkg.json'
+    result = invoke({ ...replies, [cxxTags]: tagged('v0.1.0'), [vcpkg]: { status: 404, body: '404: Not Found' } })
+    check('a final tag on a published-inventory port with no curated vcpkg entry keeps its stage',
+      same(result.ports.cxx, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' })
+      && productStatus(PORTS.find(({ slug }) => slug === 'cxx'), 'core', { schema: 2, ports: result.ports }) === '0.x', `${JSON.stringify(result.ports.cxx)} ${result.error}`)
+    // A kept baseline entry is gated too, so a failed probe cannot bring back a release the port does not have.
+    writeFileSync(join(dir, 'published.json'), JSON.stringify({ ...baseline, ports: { ...baseline.ports, julia: { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' } } }))
+    result = invoke({ ...replies, [julia]: tagged('v0.1.0'), [general]: { status: 500, body: 'unavailable' } })
+    check('a baseline entry kept after a failed probe is still unreleased',
+      same(result.ports.julia, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }), `${JSON.stringify(result.ports.julia)} ${result.error}`)
+    writeFileSync(join(dir, 'published.json'), JSON.stringify(baseline))
     // Once the registry lists a release, a newer tag it lacks is not recorded; the support page says so.
     result = invoke({ ...replies, [julia]: tagged('v0.1.0-alpha.2', 'v0.1.0'), [general]: prereleaseOnly })
     check('a final tag beside a registry that lists only a prerelease is not recorded',
       same(result.ports.julia, { status: 'prerelease', version: '0.1.0-alpha.2', release: null, tag: 'v0.1.0-alpha.2' }), `${JSON.stringify(result.ports.julia)} ${result.error}`)
 
     // The reads above pass only if the read can fail, so name the port and the tag it could not place.
-    result = invoke({ ...replies, [julia]: tagged('v0.1.0-dev.3'), [general]: notInGeneral })
+    // On a port the gate leaves alone: an unreleased port never reads its tag.
+    result = invoke({ ...replies, [cxxTags]: tagged('v0.1.0-dev.3'), [vcpkg]: { status: 404, body: '404: Not Found' } })
     check('a tag whose marker no stage names is reported with its port and name',
-      same(unread(result), ['julia core: releaseMaturity: no release stage in "v0.1.0-dev.3"']), `${JSON.stringify(unread(result))} ${result.error}`)
+      same(unread(result), ['cxx core: releaseMaturity: no release stage in "v0.1.0-dev.3"']), `${JSON.stringify(unread(result))} ${result.error}`)
+    result = invoke({ ...replies, [julia]: tagged('v0.1.0-dev.3'), [general]: notInGeneral })
+    check('an unreleased port never reads its tag, so one no stage names is not an error', same(unread(result), []), `${JSON.stringify(unread(result))} ${result.error}`)
     check('an incomplete result is not read as clean', unread({ ports: { go: seed.ports.go }, error: '' }).length === 1, 'a one-port registry read as clean')
 
     result = invoke({ ...replies, [core]: { body: feed('') }, [workspace]: { body: feed('') }, [general]: { status: 404, body: '404: Not Found' } })
diff --git a/scripts/gen-tmux-usage.mjs b/scripts/gen-tmux-usage.mjs
index fc81a5288..275a9eb33 100644
--- a/scripts/gen-tmux-usage.mjs
+++ b/scripts/gen-tmux-usage.mjs
@@ -44,6 +44,7 @@ import { forwardUsage } from './lib/tmux-usage-forward.mjs'
 import { settleCandidates, sweepCandidates } from './lib/tmux-usage-sweep.mjs'
 import { libraryScopes, scopeProblems } from './lib/tmux-usage-scopes.mjs'
 import { bindOcamlDefinitions } from './lib/tmux-usage-ocaml.mjs'
+import { nativeRakuScan } from './lib/tmux-usage-raku.mjs'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const dataDir = join(root, 'site/src/data')
@@ -242,7 +243,12 @@ export async function scanPort({ port, model, commands, checkout, known, dispatc
   }
   for (const [path, text] of sources) {
     if (grammar === 'haskell' && path.endsWith('.lhs')) throw new Error(`Haskell source usage coverage: literate input is not qualified: ${path}`)
-    const scanned = await scanSource({ grammar, text, commands: wanted, known, dispatch, builders, guards, labels, trace, native: native?.nativeScan.files[path], reviewedDigest: reviewedFiles?.[path] })
+    const rakuScan = port === 'raku' ? nativeRakuScan(text, checkout) : undefined
+    if (rakuScan && (rakuScan.compiler !== model.nativeProvenance?.exporter?.compiler
+      || !git(checkout, 'show', `${model.revision}:.tool-versions`).toString('utf8').split('\n').includes(`raku ${rakuScan.compiler}`))) {
+      throw new Error('Raku usage compiler differs from the compiler pinned by the library revision')
+    }
+    const scanned = await scanSource({ grammar, text, commands: wanted, known, dispatch, builders, guards, labels, trace, native: rakuScan ?? native?.nativeScan.files[path], reviewedDigest: reviewedFiles?.[path] })
     for (const fn of scanned.functions) functions.push({ ...fn, file: path })
     for (const type of scanned.types) types.push({ ...type, file: path })
     for (const module of scanned.modules ?? []) modules.push({ ...module, file: path })
@@ -533,8 +539,8 @@ export async function main() {
     }
     const checkout = checkoutFor(port)
     if (!existsSync(join(checkout, '.git')) && !existsSync(join(checkout, 'HEAD'))) {
-      if (check && port.slug === 'ocaml') {
-        failures.push('ocaml: source verification requires its pinned checkout; set LIBTMUX_DOCS_CHECKOUT_OCAML')
+      if (check && ['ocaml', 'raku'].includes(port.slug)) {
+        failures.push(`${port.slug}: source verification requires its pinned checkout; set LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`)
         continue
       }
       if (check) { console.log(`gen-tmux-usage: ${port.slug}: no checkout at ${checkout}; skipped regeneration`); continue }
diff --git a/scripts/lib/api-links.mjs b/scripts/lib/api-links.mjs
index 3e6ef2270..a41af0fc3 100644
--- a/scripts/lib/api-links.mjs
+++ b/scripts/lib/api-links.mjs
@@ -101,6 +101,7 @@ export function languageOfUrl(url) {
     'www.haskell.org': 'haskell', 'downloads.haskell.org': 'haskell', 'cabal.readthedocs.io': 'haskell',
     'perldoc.perl.org': 'perl', 'metacpan.org': 'perl',
     'www.lispworks.com': 'lisp', 'asdf.common-lisp.dev': 'lisp',
+    'docs.raku.org': 'raku',
     'modelcontextprotocol.io': 'any',
   }
   if (byHost[hostname]) return byHost[hostname]
@@ -117,6 +118,7 @@ export const PORT_LANGUAGES = {
   csharp: ['csharp', 'dotnet'], fsharp: ['fsharp', 'dotnet'], powershell: ['powershell', 'dotnet'],
   cxx: ['cpp'], swift: ['swift'], julia: ['julia'], lua: ['lua'], elixir: ['elixir', 'erlang'], ruby: ['ruby'], ocaml: ['ocaml'],
   haskell: ['haskell'], erlang: ['erlang'], lisp: ['lisp'],
+  raku: ['raku'],
 }
 
 /**
diff --git a/scripts/lib/core-recipes/common.mjs b/scripts/lib/core-recipes/common.mjs
index eac7776cb..8a77ceac5 100644
--- a/scripts/lib/core-recipes/common.mjs
+++ b/scripts/lib/core-recipes/common.mjs
@@ -16,6 +16,8 @@ import { resolveCheckout } from '../port-checkout.mjs'
  *   and the marked copy under `sandbox/exact` and `sandbox/marked`;
  * - `command(dir)` is the argv that runs one built copy, and `normalizeOutput`,
  *   when given, reads what it printed the way the port's own test does;
+ * - `inPlace`, when given, lists the flags that end an invocation the shim runs as tmux itself, untraced (a
+ *   foreground daemon the library owns by process id);
  * - `setup({ dir, env })`, when given, does what the page's setup commands do
  *   before the program runs (start the server it connects to). It runs without
  *   the tmux shim, so no step is credited with it, and tmux is read after it
diff --git a/scripts/lib/core-recipes/raku.mjs b/scripts/lib/core-recipes/raku.mjs
new file mode 100644
index 000000000..584921b36
--- /dev/null
+++ b/scripts/lib/core-recipes/raku.mjs
@@ -0,0 +1,124 @@
+import { execFileSync } from 'node:child_process'
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { syntaxOf } from '../../../site/src/lib/core-statement.ts'
+import { splitCommandLine } from '../core-trace.mjs'
+import { checkoutOf, instrumentLines, quickstartSource, withoutMarks } from './common.mjs'
+
+export { withoutMarks }
+
+/**
+ * How libtmux-raku's quickstart is recorded: the calls to mark, what to run,
+ * and how the library's guards are read.
+ *
+ * HAND-WRITTEN: `steps` is a person's map from the calls of the program to
+ * their anchors and to a Raku expression for the value each returned. It is
+ * checked against the program (every anchor must be found once and in the
+ * order the marks arrive), not derived from it. Every expression reads what a
+ * snapshot or handle already holds, so a mark sends tmux nothing.
+ */
+
+/**
+ * The marker helper, which goes after `use LibTmux;`: `docs-mark` runs
+ * `LIBTMUX_DOCS_MARK` with the step and the value as JSON, and stops the
+ * program if that fails.
+ */
+const PREAMBLE = [
+  'use JSON::Fast; # docs:mark',
+  'sub docs-mark(Str:D $step, $value) { my $proc = run(%*ENV<LIBTMUX_DOCS_MARK>, $step, to-json($value, :!pretty, :sorted-keys)); exit($proc.exitcode || 70) unless $proc.exitcode == 0 } # docs:mark',
+]
+
+/** A snapshot as a recording stores it: how many of each it holds. */
+const COUNTS = (name) => `%( sessions => ${name}.sessions.elems, windows => ${name}.windows.elems, panes => ${name}.panes.elems )`
+
+/**
+ * In the order the calls run. A call on a snapshot or a captured pane reads what
+ * was captured and sends tmux nothing. The last step is the displayed `LEAVE`
+ * phaser: its mark is a phaser of its own, declared before the program's, so it
+ * runs after `Server.close` has stopped the daemon.
+ */
+const STEPS = [
+  { id: 'start', label: 'Server.start', anchor: 'Server.start(', type: 'Server', value: '%( socket => $server.endpoint.socket-path.IO.parent.basename )' },
+  { id: 'snapshot-before', label: 'Server.snapshot', anchor: 'my $before = $server.snapshot;', type: 'Snapshot', value: COUNTS('$before') },
+  { id: 'pane', label: 'PaneSelection.single', anchor: 'my $left = $before.panes.single.ref;', type: 'PaneRef', value: '%( id => $left.id )' },
+  { id: 'split', label: 'PaneRef.split', anchor: '$left.split(', type: 'PaneRef', value: '%( id => $right.id )' },
+  { id: 'title-editor', label: 'PaneRef.set-title', anchor: "$left.set-title('editor');", type: 'void', value: 'Nil' },
+  { id: 'title-logs', label: 'PaneRef.set-title', anchor: "$right.set-title('logs');", type: 'void', value: 'Nil' },
+  { id: 'snapshot', label: 'Server.snapshot', anchor: 'my $after = $server.snapshot;', type: 'Snapshot', value: COUNTS('$after') },
+  { id: 'selected', label: 'PaneSelection.single', anchor: 'my $editor = $after.panes.filter(', type: 'Pane', value: '%( id => $editor.id, title => $editor.title )' },
+  { id: 'close', label: 'Server.close', anchor: 'LEAVE $server.close', type: 'void', value: 'Nil', leave: true, stopsServer: true },
+]
+
+/** Add the helper after the program's import, a mark after each call's statement, and the close mark as a phaser before the program's own. */
+export function instrumentRaku(source, steps) {
+  const syntax = syntaxOf('raku')
+  const marked = instrumentLines(source, steps.filter((step) => !step.leave), (step) => `docs-mark(${JSON.stringify(step.id)}, ${step.value}); # docs:mark`, syntax)
+  const lines = marked.split('\n')
+  for (const step of steps.filter((entry) => entry.leave)) {
+    const at = lines.findIndex((line) => line.includes(step.anchor))
+    if (at < 0 || lines.filter((line) => line.includes(step.anchor)).length !== 1) throw new Error(`${step.id}: the anchor ${JSON.stringify(step.anchor)} is not on exactly one line of the program`)
+    lines.splice(at, 0, `LEAVE docs-mark(${JSON.stringify(step.id)}, ${step.value}); # docs:mark`)
+  }
+  const import_ = lines.indexOf('use LibTmux;')
+  if (import_ < 0) throw new Error('the program has no `use LibTmux;` line to put the marker helper after')
+  lines.splice(import_ + 1, 0, ...PREAMBLE)
+  return lines.join('\n')
+}
+
+/**
+ * Each command is sent inside a guard that fails unless the daemon is the one the library checked:
+ * `if-shell -F <check> '<command words>' libtmux-stale-<token>`. The words of the command inside.
+ */
+const unwrap = (command) => (command[0] === 'if-shell' && command[1] === '-F' && /^libtmux-stale-[0-9a-f]{32}/.test(command.at(-1) ?? '') ? splitCommandLine(command[3]) : undefined)
+
+/** The compiler the checkout pins: the sandbox's home has no version manager configuration, so the shim would pick the system's. */
+const raku = (checkout) => execFileSync('mise', ['exec', `raku@${/^raku (\S+)$/m.exec(readFileSync(join(checkout, '.tool-versions'), 'utf8'))?.[1]}`, '--', 'sh', '-c', 'command -v raku'], { encoding: 'utf8' }).trim()
+
+/** The checkout the program was built against, which pins the compiler. */
+let built
+
+export const RECIPES = {
+  'typed-graph': {
+    capability: 'typed-graph',
+    file: 'quickstart.raku',
+    stepMap: 'hand-written',
+    source: (root) => quickstartSource(root, 'raku', 'quickstart.raku'),
+    /** What a pane runs once it has settled: both panes run `exec cat`, which replaces their shell. */
+    paneCommands: ['cat'],
+    checkout: (port, env, expand) => checkoutOf(port, env, expand),
+    /** The library makes its owned socket directory under TMPDIR as `libtmux-owned-<six characters>`. */
+    socket: { pattern: 'libtmux-owned-[A-Za-z0-9]{6}', fixed: 'libtmux-owned-AbC123' },
+    helpers: [],
+    steps: STEPS,
+    fence: () => false,
+    /** The library starts its daemon as `tmux -D` and binds to that process, so the shim becomes tmux for it instead of wrapping it. */
+    inPlace: ['-D'],
+    unwrap,
+    /**
+     * What the library asks tmux about itself: its version before it starts or uses a daemon, the daemon it starts in the
+     * foreground, and the identity probe it sends before each command.
+     */
+    probe: ({ commands }) => commands.length === 0
+      || commands.every((command) => command[0] === 'run-shell' && command.includes('-C') && command.some((word) => word.startsWith('libtmux-probe-'))),
+    /** The probe's channel and the guard's failure token are random on every run. */
+    redact: (text) => text.replace(/(libtmux-(?:probe|stale))-[0-9a-f]{32}/g, '$1-00000000000000000000000000000000'),
+    instrument: instrumentRaku,
+    command: (dir) => ['/bin/sh', join(dir, 'program')],
+    toolchain: () => ({ raku: /v(\d{4}\.\d{2}(?:\.\d+)?)/.exec(execFileSync(raku(built), ['--version'], { encoding: 'utf8' }))?.[1] ?? 'unknown' }),
+    /** Write the displayed program, and the marked copy beside it, with a launcher that puts the checkout's modules on the path. */
+    build({ sandbox, checkout, code, marked }) {
+      built = checkout
+      const compiler = raku(checkout)
+      mkdirSync(join(sandbox, 'tmp'), { recursive: true })
+      // Precompile the library once, so that no run spends its first seconds on it.
+      execFileSync(compiler, ['-I', checkout, '-e', 'use LibTmux'], { encoding: 'utf8', timeout: 600000 })
+      for (const [dir, source] of [['exact', code], ['marked', marked]]) {
+        writeFileSync(join(sandbox, dir, this.file), source)
+        // A run stopped at a mark leaves its socket directory behind, and a second socket would make the sandbox ambiguous.
+        // A window made with `exec cat` keeps the name `sh`, which tmux does not change until the pane writes.
+        writeFileSync(join(sandbox, dir, 'program'), `#!/bin/sh\nTMPDIR=${JSON.stringify(join(sandbox, 'tmp'))}\nrm -rf "$TMPDIR"/libtmux-owned-*\nLIBTMUX_DOCS_WINDOW_NAMES=sh\nexport TMPDIR LIBTMUX_DOCS_WINDOW_NAMES\nexec ${JSON.stringify(compiler)} -I ${JSON.stringify(checkout)} ${this.file}\n`)
+        chmodSync(join(sandbox, dir, 'program'), 0o755)
+      }
+    },
+  },
+}
diff --git a/scripts/lib/core-trace.mjs b/scripts/lib/core-trace.mjs
index d96d05eea..59b5e13cf 100644
--- a/scripts/lib/core-trace.mjs
+++ b/scripts/lib/core-trace.mjs
@@ -189,14 +189,22 @@ function quietReply(directory, seq) {
  * by it, so a control invocation does not run inside the shim: the script logs
  * the startup command, starts a reader of the program's input and a reader of
  * tmux's output, and becomes the real tmux with both through pipes. Anything
- * else runs through `shim`.
+ * else runs through `shim`. An invocation whose last word is one of `inPlace` becomes
+ * the real tmux untraced, for a foreground daemon (`-D`) that a library owns by the
+ * process id it started: libtmux-raku binds the daemon to that id, and a wrapper
+ * process in between would make it a stranger. Such an invocation has no command to trace.
  *
- * @param {{ node: string, entry: string }} where the node binary and `core-trace.mjs`
+ * @param {{ node: string, entry: string, inPlace?: string[] }} where the node binary and `core-trace.mjs`, and the flags that end an in-place invocation
  */
-export const shimScript = ({ node, entry }) => `#!/bin/sh
+export const shimScript = ({ node, entry, inPlace = [] }) => `#!/bin/sh
 NODE=${JSON.stringify(node)}
 ENTRY=${JSON.stringify(entry)}
-for word in "$@"; do
+${inPlace.length === 0 ? '' : `last=
+for word in "$@"; do last=$word; done
+case $last in
+  ${inPlace.map((flag) => JSON.stringify(flag)).join('|')}) exec "$LIBTMUX_DOCS_REAL_TMUX" "$@" ;;
+esac
+`}for word in "$@"; do
   case $word in
     -*C*)
       if "$NODE" "$ENTRY" is-control "$@"; then
diff --git a/scripts/lib/destination-verification.mjs b/scripts/lib/destination-verification.mjs
index fa4bb0ab8..04211d537 100644
--- a/scripts/lib/destination-verification.mjs
+++ b/scripts/lib/destination-verification.mjs
@@ -17,6 +17,8 @@
  */
 
 import { documentedLibrary, entryCandidates, entryDestinations } from '../../site/src/lib/port-inventory.ts'
+import { readPage } from './api-html.mjs'
+import { pageIdentity } from './api-identities.mjs'
 
 export const USER_AGENT = 'libtmux-docs destination check (+https://libtmux.org)'
 
@@ -373,6 +375,64 @@ const VERIFIERS = {
         exact: async (wanted) => { const page = await get(`https://${name}.hexdocs.pm/${wanted}/`); return page.status === 200 && titleOf(page.text) === titled(wanted) } })
       : fail('identity', `title is "${title}", expected the documentation of ${name}`, { status: 200, requested: url })
   },
+
+  async metacpan({ url }, { get }) {
+    const [, kind, name] = /^https:\/\/metacpan\.org\/(dist|pod)\/([^/]+)$/.exec(url) ?? []
+    if (!kind) return fail('identity', `${url} is neither a distribution (/dist/) nor a module's POD (/pod/) page of metacpan.org`)
+    // MetaCPAN answers scripted clients with a challenge page, so its own API names the distribution or module.
+    // The API's `pod` endpoint renders the page's body, so a module's POD is read from its NAME section.
+    const api = (path) => `https://fastapi.metacpan.org/v1/${path}`
+    let dist = name
+    let version
+    if (kind === 'pod') {
+      const requested = api(`module/${name}`)
+      const response = await get(requested, { accept: 'application/json' })
+      const missing = answered(response, requested)
+      if (missing) return missing
+      const module = json(response.text)
+      // Files that declare several packages answer for each; only the one that documents the file has this page.
+      if (module?.documentation !== name) return fail('identity', `MetaCPAN documents "${module?.documentation}" in ${module?.path}, expected "${name}"`, { status: 200, requested })
+      dist = module.distribution
+      version = module.version
+      const rendered = await get(api(`pod/${name}`))
+      const refused = answered(rendered, api(`pod/${name}`))
+      if (refused) return refused
+      const declared = pageIdentity(url, readPage(rendered.text))
+      if (declared?.via !== 'pod' || declared.path.join('::') !== name) return fail('identity', `the POD names "${declared?.path?.join('::') ?? ''}" in its NAME section, expected "${name}"`, { status: 200, requested: api(`pod/${name}`) })
+    }
+    const requested = api(`release/${dist}`)
+    const response = await get(requested, { accept: 'application/json' })
+    const missing = answered(response, requested)
+    if (missing) return missing
+    const release = json(response.text)
+    if (release?.distribution !== dist) return fail('identity', `MetaCPAN names the distribution "${release?.distribution}", expected "${dist}"`, { status: 200, requested })
+    const listing = await get(api(`release/_search?q=distribution:${dist}&size=100`), { accept: 'application/json' })
+    // A developer release and one BackPAN holds are not what `cpm install` resolves.
+    const versions = (json(listing.text)?.hits?.hits ?? []).map((hit) => hit._source)
+      .filter((entry) => entry?.distribution === dist && entry.maturity === 'released' && entry.status !== 'backpan').map((entry) => entry.version)
+    return pass({ status: 200, requested: kind === 'pod' ? api(`module/${name}`) : requested, identity: name, version: version ?? release.version, versions,
+      repository: reposOf([release.resources?.repository?.url, release.resources?.repository?.web, release.resources?.homepage]) })
+  },
+  async 'raku-land'({ url }, { get }) {
+    // Raku Land names a distribution by its Fez authority and its name, and answers 404 for an unknown one.
+    const [, authority, name] = /^https:\/\/raku\.land\/(zef:[^/?#]+)\/([^/?#]+)$/.exec(url) ?? []
+    if (!name) return fail('identity', `${url} is not a distribution page under a zef authority on raku.land`)
+    const response = await get(url)
+    const missing = answered(response, url)
+    if (missing) return missing
+    const title = titleOf(response.text)
+    if (title !== `Raku Land - ${name}`) return fail('identity', `title is "${title}", expected "Raku Land - ${name}"`, { status: 200, requested: url })
+    // The version selector lists every release and marks the one shown.
+    const options = [...response.text.matchAll(/<option\s+value="([^"]+)"([^>]*)>/g)].map(([, value, attributes]) => ({ value, selected: /\bselected\b/.test(attributes) }))
+    const sources = [...response.text.matchAll(/<a\s+href="(https:\/\/github\.com\/[^"/]+\/[^"/]+)"[^>]*>\s*github\.com\/[^<\s]+\s*</g)].map((match) => match[1])
+    return pass({ status: 200, requested: url, identity: `${name}:auth<${authority}>`, version: options.find((option) => option.selected)?.value,
+      versions: options.map((option) => option.value), repository: reposOf(sources),
+      exact: async (wanted) => {
+        const page = await get(`${url}?v=${encodeURIComponent(wanted)}`)
+        return page.status === 200 && titleOf(page.text) === title
+          && [...page.text.matchAll(/<option\s+value="([^"]+)"([^>]*)>/g)].some(([, value, attributes]) => value === wanted && /\bselected\b/.test(attributes))
+      } })
+  },
 }
 
 /**
@@ -390,15 +450,24 @@ const SAMPLES = { 'javadoc-io': 3 }
 export const VERSION_SUPPORT = {
   github: false, pypi: true, npm: true, crates: true, rubygems: true, 'powershell-gallery': true, nuget: true, luarocks: true,
   'maven-central': true, 'swift-package-index': true, 'pkg-go-dev': true, 'docs-rs': true, 'javadoc-io': true, hex: true, hexdocs: true,
+  metacpan: true,
+  'raku-land': true,
 }
+/**
+ * Where a host never lists a kind of version, so a manifest that declares one has not claimed a release. PAUSE
+ * indexes no CPAN developer release (`0.001_001`), and a pinned manifest at a development commit may declare one.
+ */
+export const DEVELOPER_VERSION = { metacpan: /^\d+\.\d+_\d+$/ }
 /** Hosts whose records must name the repository the host reports. */
-export const REPOSITORY_HOSTS = new Set(['pypi', 'npm', 'crates', 'rubygems', 'powershell-gallery', 'nuget', 'luarocks', 'maven-central', 'swift-package-index', 'javadoc-io', 'hex'])
+export const REPOSITORY_HOSTS = new Set(['pypi', 'npm', 'crates', 'rubygems', 'powershell-gallery', 'nuget', 'luarocks', 'maven-central', 'swift-package-index', 'javadoc-io', 'hex', 'metacpan',
+  'raku-land'])
 
 const HOSTNAMES = {
   'pypi.org': 'pypi', 'www.npmjs.com': 'npm', 'crates.io': 'crates', 'rubygems.org': 'rubygems',
   'www.powershellgallery.com': 'powershell-gallery', 'www.nuget.org': 'nuget', 'luarocks.org': 'luarocks',
   'central.sonatype.com': 'maven-central', 'swiftpackageindex.com': 'swift-package-index', 'pkg.go.dev': 'pkg-go-dev',
-  'docs.rs': 'docs-rs', 'javadoc.io': 'javadoc-io', 'github.com': 'github', 'hex.pm': 'hex',
+  'docs.rs': 'docs-rs', 'javadoc.io': 'javadoc-io', 'github.com': 'github', 'hex.pm': 'hex', 'metacpan.org': 'metacpan',
+  'raku.land': 'raku-land',
 }
 /** The host id of a URL; HexDocs serves each package from a subdomain of `hexdocs.pm`. */
 export const hostOf = (url) => {
@@ -419,7 +488,9 @@ async function versionChecks(result, destination) {
   const checks = []
   for (const { version, source, ports } of expected) {
     const base = { version, source, ports }
-    if (typeof result.exact === 'function') checks.push({ ...base, check: (await result.exact(version)) ? 'confirmed' : 'absent' })
+    if (DEVELOPER_VERSION[destination.host]?.test(version)) {
+      checks.push({ ...base, check: 'developer', note: `${version} is a developer version, which ${destination.host} does not list as a release` })
+    } else if (typeof result.exact === 'function') checks.push({ ...base, check: (await result.exact(version)) ? 'confirmed' : 'absent' })
     else if (Array.isArray(result.versions)) checks.push({ ...base, check: result.versions.includes(version) ? 'confirmed' : 'absent' })
     else checks.push({ ...base, check: 'unsupported', note: `${destination.host} does not list versions` })
   }
@@ -632,7 +703,9 @@ export function checkEvidence(inventory, evidence, { manifests, today = new Date
     if (checks.length === 0) problems.push(`${url} says nothing of its version; record why a host cannot confirm one`)
     for (const check of checks) {
       if (check.check === 'absent') problems.push(`${url} does not carry ${check.version}, the version ${check.source} declares for ${check.ports.join(', ')}`)
-      else if (check.check !== 'confirmed' && check.version && VERSION_SUPPORT[destination.host]) {
+      else if (check.check === 'developer') {
+        if (!DEVELOPER_VERSION[destination.host]?.test(check.version ?? '')) problems.push(`${url} records ${check.version} as a developer version, which ${destination.host} does not issue`)
+      } else if (check.check !== 'confirmed' && check.version && VERSION_SUPPORT[destination.host]) {
         problems.push(`${url} could not confirm ${check.version} on ${destination.host}, which lists versions (${check.check}: ${check.note ?? 'no reason given'})`)
       }
     }
diff --git a/scripts/lib/manifest-packages.mjs b/scripts/lib/manifest-packages.mjs
index 71219eb72..669c5d30f 100644
--- a/scripts/lib/manifest-packages.mjs
+++ b/scripts/lib/manifest-packages.mjs
@@ -266,6 +266,13 @@ const READERS = {
     return { distributions, units: [] }
   },
 
+  /** META6.json is JSON: the root file names the one distribution zef publishes. */
+  raku(repo) {
+    const { name, version } = JSON.parse(repo.read('META6.json'))
+    if (typeof name !== 'string' || typeof version !== 'string') throw new Error('Invalid META6.json: name and version are required')
+    return { distributions: [{ name, version, manifest: 'META6.json' }], units: [] }
+  },
+
   /** One source distribution exports the non-test ASDF systems and workspace script. */
   lisp(repo) {
     const manifest = 'libtmux.asd'
@@ -285,6 +292,7 @@ const READER_FOR = {
   java: 'java', clojure: 'java', kotlin: 'java', scala: 'java', csharp: 'dotnet', fsharp: 'dotnet', cxx: 'cxx', swift: 'swift', elixir: 'elixir', ocaml: 'ocaml',
   haskell: 'haskell',
   lisp: 'lisp', erlang: 'erlang',
+  raku: 'raku',
 }
 
 /**
diff --git a/scripts/lib/perl-pod.mjs b/scripts/lib/perl-pod.mjs
new file mode 100644
index 000000000..58fa0bf30
--- /dev/null
+++ b/scripts/lib/perl-pod.mjs
@@ -0,0 +1,118 @@
+/**
+ * What a CPAN release's POD offers, as MetaCPAN's own API reports it.
+ *
+ * MetaCPAN answers scripted clients' page requests with a challenge, so a link
+ * into a release's POD cannot be checked on the page. Its API can: `release`
+ * lists the modules a distribution provides, `module` says which file documents
+ * each, `pod` renders that file's POD with the same renderer as the page, and
+ * `source` returns the file. A rendered heading's `id` is the fragment the page
+ * answers to, and the file's SHA-256 is what lets a reference page show that it
+ * documents the same bytes the release shipped.
+ *
+ * The functions take a `get(url)` that answers `{ status, text, bytes }`, so a
+ * test can serve them offline.
+ */
+import { createHash } from 'node:crypto'
+import { readPage } from './api-html.mjs'
+import { pageIdentity } from './api-identities.mjs'
+
+export const API = 'https://fastapi.metacpan.org/v1'
+export const SCHEMA = 1
+
+const SHA256 = /^[a-f0-9]{64}$/
+const MODULE = /^[A-Za-z_]\w*(?:::\w+)*$/
+const FRAGMENT_TAGS = new Set(['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'dt'])
+
+async function json(get, url) {
+  const response = await get(url)
+  if (response.status !== 200) throw new Error(`${url} answered ${response.status}`)
+  try {
+    return JSON.parse(response.text)
+  } catch {
+    throw new Error(`${url} did not answer JSON`)
+  }
+}
+
+/**
+ * The fragments a rendered POD page answers to: the `id` of each heading and
+ * each `=item`, in document order. A repeated heading is suffixed by the
+ * renderer, so `new` and `new-1` are different fragments.
+ */
+export function podAnchors(html) {
+  return [...new Set(readPage(html).anchors.filter((anchor) => FRAGMENT_TAGS.has(anchor.tag)).map((anchor) => anchor.id))]
+}
+
+/**
+ * One distribution's latest release: the document each provided package
+ * belongs to, and for each document its file, the file's SHA-256 and the
+ * fragments of its rendered POD.
+ *
+ * A distribution that is not the latest released one, a package MetaCPAN lists
+ * in another release, and a POD whose NAME section names another module all
+ * throw: a link built from such a record would open the wrong page.
+ */
+export async function observeDistribution(get, dist) {
+  const release = await json(get, `${API}/release/${dist}`)
+  if (release?.distribution !== dist || release.status !== 'latest' || release.maturity !== 'released'
+      || !/^\d+\.\d+$/.test(release.version ?? '') || !/^[A-Z0-9]+$/.test(release.author ?? '') || !Array.isArray(release.provides)) {
+    throw new Error(`${dist}: MetaCPAN does not name it as a released distribution (${release?.distribution} ${release?.version} ${release?.status})`)
+  }
+  const packages = {}
+  const files = new Map()
+  for (const name of [...release.provides].sort()) {
+    if (!MODULE.test(name)) throw new Error(`${dist}: ${name} is not a module name`)
+    const module = await json(get, `${API}/module/${name}`)
+    if (module?.distribution !== dist || module.release !== release.name) {
+      throw new Error(`${dist}: MetaCPAN files ${name} under ${module?.release}, not ${release.name}`)
+    }
+    // A package without POD of its own, and one documented in another's file, are both recorded as the file says.
+    const documented = module.documentation ?? null
+    if (documented !== null && !MODULE.test(documented)) throw new Error(`${dist}: ${name} is documented as "${documented}"`)
+    packages[name] = documented
+    if (documented !== null) {
+      if (files.has(documented) && files.get(documented) !== module.path) throw new Error(`${dist}: ${documented} is documented in two files`)
+      files.set(documented, module.path)
+    }
+  }
+  const documents = {}
+  for (const [name, path] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
+    if (!/^lib\/.+\.(?:pm|pod)$/.test(path)) throw new Error(`${dist}: ${name} is documented in ${path}, outside lib/`)
+    const pod = await get(`${API}/pod/${name}`)
+    if (pod.status !== 200) throw new Error(`${API}/pod/${name} answered ${pod.status}`)
+    // The page's own NAME section decides what it documents, not its address.
+    const identity = pageIdentity(`https://metacpan.org/pod/${name}`, readPage(pod.text))
+    if (identity?.via !== 'pod' || identity.path.join('::') !== name) {
+      throw new Error(`${dist}: the POD for ${name} names "${identity?.path?.join('::') ?? ''}" in its NAME section`)
+    }
+    const source = await get(`${API}/source/${release.author}/${release.name}/${path}`)
+    if (source.status !== 200) throw new Error(`${API}/source/${release.author}/${release.name}/${path} answered ${source.status}`)
+    documents[name] = { path, sha256: createHash('sha256').update(source.bytes).digest('hex'), anchors: podAnchors(pod.text) }
+  }
+  return { author: release.author, release: release.version, documents, packages }
+}
+
+/**
+ * Everything wrong with a recorded observation, as sentences: the schema, a
+ * package that names a document the record lacks, a document no package
+ * names, a fragment listed twice, and a digest that is not one.
+ */
+export function problemsWith(data, expected) {
+  const problems = []
+  if (data?.schema !== SCHEMA) return [`schema is ${data?.schema}, expected ${SCHEMA}`]
+  const recorded = Object.keys(data.distributions ?? {})
+  for (const dist of expected) if (!recorded.includes(dist)) problems.push(`${dist} has no recorded release`)
+  for (const dist of recorded) if (!expected.includes(dist)) problems.push(`${dist} is recorded but not a package of the port`)
+  for (const [dist, release] of Object.entries(data.distributions ?? {})) {
+    if (!/^\d+\.\d+$/.test(release.release ?? '')) problems.push(`${dist}: release "${release.release}" is not a decimal version`)
+    for (const [name, document] of Object.entries(release.documents ?? {})) {
+      if (!SHA256.test(document.sha256 ?? '')) problems.push(`${dist}: ${name} has no SHA-256`)
+      if (!(document.path ?? '').startsWith('lib/')) problems.push(`${dist}: ${name} is documented outside lib/`)
+      if (new Set(document.anchors).size !== document.anchors?.length || !document.anchors?.includes('NAME')) problems.push(`${dist}: ${name} lists its fragments wrongly`)
+      if (!Object.values(release.packages ?? {}).includes(name)) problems.push(`${dist}: no package is documented by ${name}`)
+    }
+    for (const [name, documented] of Object.entries(release.packages ?? {})) {
+      if (documented !== null && !(documented in (release.documents ?? {}))) problems.push(`${dist}: ${name} is documented by ${documented}, which the record lacks`)
+    }
+  }
+  return problems
+}
diff --git a/scripts/lib/tmux-usage-dispatch.mjs b/scripts/lib/tmux-usage-dispatch.mjs
index b9eeb2fc0..9b7b1d1f4 100644
--- a/scripts/lib/tmux-usage-dispatch.mjs
+++ b/scripts/lib/tmux-usage-dispatch.mjs
@@ -250,7 +250,7 @@ export function preflightProblems({ port, preflights, readSource }) {
       if (text === undefined) { problems.push(`${label}: ${item.at} is not a line of the pinned source`); continue }
       for (const needle of item.has ?? []) if (!text.includes(needle)) problems.push(`${label}: ${item.at} does not contain ${JSON.stringify(needle)}`)
     }
-    if (!rule.evidence.some((item) => (item.has ?? []).some((needle) => needle.includes(`"${rule.command}"`)))) problems.push(`${label}: no cited line spells the command`)
+    if (!rule.evidence.some((item) => (item.has ?? []).some((needle) => ['"', "'"].some((quote) => needle.includes(`${quote}${rule.command}${quote}`))))) problems.push(`${label}: no cited line spells the command`)
   }
   return problems
 }
diff --git a/scripts/lib/tmux-usage-raku.mjs b/scripts/lib/tmux-usage-raku.mjs
new file mode 100644
index 000000000..eb59aec06
--- /dev/null
+++ b/scripts/lib/tmux-usage-raku.mjs
@@ -0,0 +1,34 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+
+export const rakuDigest = (value) => createHash('sha256').update(value).digest('hex')
+
+/**
+ * Parse trusted library source with the compiler the checkout pins, never with JavaScript syntax rules.
+ * RakuAST can run compile-time code, so only a reviewed library revision is read this way.
+ */
+export function nativeRakuScan(text, checkout) {
+  const result = spawnSync(process.env.LIBTMUX_DOCS_RAKU || 'raku', [
+    ...(checkout ? ['-I.'] : []), fileURLToPath(new URL('./tmux-usage-raku.raku', import.meta.url)),
+  ], { cwd: checkout, input: text, encoding: 'utf8', maxBuffer: 64 << 20 })
+  if (result.error || result.status !== 0) throw new Error(`Native Raku source scan failed: ${result.error?.message ?? result.stderr}`)
+  return { ...JSON.parse(result.stdout), sha256: rakuDigest(text) }
+}
+
+/** Dynamic Invocation plans need reviewed dispatch and scope claims, as the native Perl reader does. */
+export function scanRaku(text, native, { commands, known }) {
+  if (!text) return { functions: [], types: [], orphans: [] }
+  if (!native || native.sha256 !== rakuDigest(text)) throw new Error('Raku analysis requires native input for these exact bytes')
+  const functions = native.functions.map(({ literals, calls, ...fn }) => ({
+    ...fn,
+    sites: literals.filter(({ value }) => known.has(value) && commands.has(value)).map(({ value, line }) => ({
+      command: value, line, flags: '', dispatch: null,
+      why: 'RakuAST literal in an Invocation plan; dispatch and scope require reviewed source evidence',
+    })),
+    calls: new Map(calls.map(({ name, line }) => [name, line])),
+    receivers: new Map(calls.map(({ name, receiver }) => [name, new Set(receiver ? [receiver] : [])])),
+    callList: calls,
+  }))
+  return { functions, types: native.types, orphans: [] }
+}
diff --git a/scripts/lib/tmux-usage-raku.raku b/scripts/lib/tmux-usage-raku.raku
new file mode 100644
index 000000000..94cabb8d3
--- /dev/null
+++ b/scripts/lib/tmux-usage-raku.raku
@@ -0,0 +1,62 @@
+use v6.d;
+use experimental :rakuast;
+use JSON::Fast;
+
+# Trusted source can execute compile-time code during RakuAST parsing.
+my $text = $*IN.slurp;
+my $tree = $text.AST;
+my @functions;
+my @types;
+my %seen;
+sub line-at(Int:D $offset --> Int:D) { 1 + $text.substr(0, $offset).comb("\n").elems }
+sub walk($node, Str:D $owner = '', Int:D $function = -1, Str:D $receiver = '') {
+    return if %seen{$node.WHICH}++;
+    my $kind = $node.^name;
+    return if $kind.starts-with('RakuAST::Doc::');
+    my $next-owner = $owner;
+    my $next-function = $function;
+    if $kind eq any(<RakuAST::Class RakuAST::Role RakuAST::Module>) {
+        $next-owner = $node.name.DEPARSE.split('::').tail;
+        @types.push(%(name => $next-owner, start => line-at($node.origin.from),
+            end => line-at($node.origin.to))) if $node.origin.defined;
+    }
+    if $kind eq any(<RakuAST::Method RakuAST::Sub RakuAST::Submethod>)
+            && $node.origin.defined && $node.name.defined {
+        my $name = $node.name.DEPARSE;
+        $name = '!' ~ $name if $node.^can('private') && $node.private;
+        my %fn = :$name, start => line-at($node.origin.from),
+            nameLine => line-at($node.origin.from), end => line-at($node.origin.to),
+            kind => $kind, literals => [], calls => [];
+        %fn<owner> = $owner if $owner.chars;
+        $next-function = @functions.elems;
+        @functions.push(%fn);
+    }
+    if $function >= 0 && $node.origin.defined {
+        if $kind eq 'RakuAST::QuotedString' {
+            unless $node.has-variables {
+                my $value = $node.literal-value;
+                for ($value ~~ Positional ?? $value.List !! ($value,)) -> $literal {
+                    @functions[$function]<literals>.push(%(value => $literal,
+                        line => line-at($node.origin.from))) if $literal ~~ Str;
+                }
+            }
+            return;
+        }
+        if $kind eq any(<RakuAST::Call::Name RakuAST::Call::Method RakuAST::Call::PrivateMethod>) {
+            my $name = $node.name.DEPARSE;
+            $name = '!' ~ $name if $kind eq 'RakuAST::Call::PrivateMethod';
+            my %call = :$name, line => line-at($node.origin.from);
+            %call<receiver> = $receiver if $receiver.chars;
+            @functions[$function]<calls>.push(%call);
+        }
+    }
+    if $kind eq 'RakuAST::ApplyPostfix' {
+        walk($node.operand, $next-owner, $next-function);
+        walk($node.postfix, $next-owner, $next-function, $node.operand.DEPARSE);
+    } else {
+        $node.visit-children(-> $child { walk($child, $next-owner, $next-function) });
+    }
+}
+walk($tree);
+say to-json(%(compiler => $*RAKU.compiler.version.Str,
+    functions => @functions, types => @types), :sorted-keys);
diff --git a/scripts/lib/tmux-usage-scan.mjs b/scripts/lib/tmux-usage-scan.mjs
index 98813a5f9..cb1ed0836 100644
--- a/scripts/lib/tmux-usage-scan.mjs
+++ b/scripts/lib/tmux-usage-scan.mjs
@@ -7,6 +7,7 @@
  * with the command, because the flags choose the scope tmux lists.
  */
 import { scanPerl } from './tmux-usage-perl.mjs'
+import { scanRaku } from './tmux-usage-raku.mjs'
 import { parserFor } from '../../packages/api-model/src/parser.ts'
 import { receiverOf, scanElixir, scanFSharp, scanJulia, scanLisp } from './tmux-usage-lexical.mjs'
 import { scanHaskell } from './tmux-usage-haskell.mjs'
@@ -15,6 +16,7 @@ import { scanErlang } from './tmux-usage-erlang.mjs'
 
 /** Port to its source reader. PowerShell cmdlets are C#; Julia, F#, Elixir and Erlang use lexical readers. */
 export const GRAMMARS = {
+  raku: 'raku',
   perl: 'perl', py: 'python', ts: 'typescript', rs: 'rust', go: 'go', java: 'java', clojure: 'clojure', kotlin: 'kotlin', scala: 'scala',
   csharp: 'csharp', powershell: 'csharp', cxx: 'cpp', swift: 'swift', ruby: 'ruby', lua: 'lua', julia: 'julia', fsharp: 'fsharp', elixir: 'elixir', ocaml: 'ocaml',
   haskell: 'haskell',
@@ -24,6 +26,7 @@ export const GRAMMARS = {
 
 /** Source extensions per grammar, minus declaration-only files. */
 export const EXTENSIONS = {
+  raku: /\.rakumod$/,
   perl: /\.pm$/, python: /\.py$/, typescript: /(?<!\.d)\.ts$/, rust: /\.rs$/, go: /\.go$/, java: /\.java$/, clojure: /\.clj$/, kotlin: /\.kt$/,
   scala: /\.scala$/, csharp: /\.cs$/, cpp: /\.(?:cpp|cc|cxx|hpp|hh|h)$/, swift: /\.swift$/, ruby: /\.rb$/, lua: /\.lua$/, julia: /\.jl$/, fsharp: /\.fs$/, elixir: /\.ex$/, ocaml: /\.ml$/,
   haskell: /\.l?hs$/,
@@ -622,6 +625,7 @@ export async function scanSource({ grammar, text, commands, known, dispatch, bui
     return false
   }
   if (grammar === 'perl') return scanPerl(text, native, { commands, known })
+  if (grammar === 'raku') return scanRaku(text, native, { commands, known })
   if (grammar === 'julia') return scanJulia(text, { commands, known, dispatch })
   if (grammar === 'elixir') return scanElixir(text, { commands, known, dispatch })
   if (grammar === 'erlang') return scanErlang(text, { commands, known, dispatch, builders, labels })
diff --git a/scripts/lib/tmux-usage-sweep.mjs b/scripts/lib/tmux-usage-sweep.mjs
index 5828d02dc..82dba2c32 100644
--- a/scripts/lib/tmux-usage-sweep.mjs
+++ b/scripts/lib/tmux-usage-sweep.mjs
@@ -24,6 +24,7 @@ export const OPTION_SPELLINGS = new Set(['set-window-option', 'show-window-optio
 
 /** Where the library itself lives in each port, so a consumer package or a test helper is not swept. */
 export const LIBRARY_ROOTS = {
+  raku: ['lib/'],
   perl: ['packages/core/lib/', 'packages/async/lib/'],
   py: ['src/libtmux/'],
   ruby: ['gems/libtmux/', 'gems/libtmux-async/'],
diff --git a/scripts/test-all.sh b/scripts/test-all.sh
index 94519f13f..5cdf42f07 100755
--- a/scripts/test-all.sh
+++ b/scripts/test-all.sh
@@ -247,6 +247,19 @@ node scripts/verify-destinations.mjs --check
 step 'destination verification (negative)'
 node scripts/verify-destinations.negative.mjs
 
+# A Perl reference page links a declaration to its section of the POD on
+# MetaCPAN only where the latest CPAN release has that fragment. The record of
+# each release's documents, file digests and fragments is read from MetaCPAN's
+# API (node scripts/gen-perl-pod.mjs, re-checked weekly by the same workflow as
+# the destinations). This reads the committed file and requests nothing: a
+# distribution dropped, a digest that is not one, a package naming a missing
+# document and a repeated fragment all fail.
+step 'perl pod record'
+node scripts/gen-perl-pod.mjs --check --offline
+
+step 'perl pod record (negative)'
+node scripts/gen-perl-pod.negative.mjs
+
 # The standard-library and SDK links the reference pages, guides and glossary
 # make. Each lands on the page, fragment and symbol it names, as the host's own
 # page shows (node scripts/verify-api-destinations.mjs, re-run weekly by the
diff --git a/scripts/tmux-usage/claims.json b/scripts/tmux-usage/claims.json
index c7abccdd1..da80868ae 100644
--- a/scripts/tmux-usage/claims.json
+++ b/scripts/tmux-usage/claims.json
@@ -31033,6 +31033,7321 @@
           ]
         }
       ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.display-message",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:142",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.display-message"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:138",
+          "has": [
+            "my @argv = 'display-message', '-c', self!target, '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.display-message",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:142",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.display-message"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:138",
+          "has": [
+            "my @argv = 'display-message', '-c', self!target, '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.display-format",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:151",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.display-format"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:148",
+          "has": [
+            "my @argv = 'display-message', '-c', self!target, '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.display-format",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:151",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.display-format"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:148",
+          "has": [
+            "my @argv = 'display-message', '-c', self!target, '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.menu-async",
+      "command": "display-menu",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:184",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$pane, :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.menu-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:163",
+          "has": [
+            "my @argv = 'display-menu', '-c', self!target, '-t', $pane,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.menu-async",
+      "command": "display-menu",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:184",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$pane, :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.menu-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:163",
+          "has": [
+            "my @argv = 'display-menu', '-c', self!target, '-t', $pane,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.popup-async",
+      "command": "display-popup",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:208",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$pane, :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.popup-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:197",
+          "has": [
+            "my @argv = 'display-popup', '-c', self!target, '-t', $pane,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.popup-async",
+      "command": "display-popup",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:208",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$pane, :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.popup-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:197",
+          "has": [
+            "my @argv = 'display-popup', '-c', self!target, '-t', $pane,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.close-popup",
+      "command": "display-popup",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:213",
+          "has": [
+            "await self!run(Invocation.new(:argv(['display-popup', '-C', '-c', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.close-popup"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.close-popup",
+      "command": "display-popup",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:213",
+          "has": [
+            "await self!run(Invocation.new(:argv(['display-popup', '-C', '-c', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.close-popup"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.prompt-async",
+      "command": "command-prompt",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:233",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.prompt-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:225",
+          "has": [
+            "my @argv = 'command-prompt', '-t', self!target, '-p', literal-format(text($prompts)),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.prompt-async",
+      "command": "command-prompt",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:233",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.prompt-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:225",
+          "has": [
+            "my @argv = 'command-prompt', '-t', self!target, '-p', literal-format(text($prompts)),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.confirm-async",
+      "command": "confirm-before",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:239",
+          "has": [
+            "self!run(Invocation.new(:argv(['confirm-before', '-t', self!target,"
+          ],
+          "in": "LibTmux::Client::ClientTarget.confirm-async"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.confirm-async",
+      "command": "confirm-before",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:239",
+          "has": [
+            "self!run(Invocation.new(:argv(['confirm-before', '-t', self!target,"
+          ],
+          "in": "LibTmux::Model::ClientRef.confirm-async"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.choose",
+      "command": "choose-tree",
+      "scope": null,
+      "when": "kind is tree",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:250",
+          "has": [
+            "my %commands = tree => 'choose-tree', client => 'choose-client',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.choose",
+      "command": "choose-tree",
+      "scope": null,
+      "when": "kind is tree",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:250",
+          "has": [
+            "my %commands = tree => 'choose-tree', client => 'choose-client',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.choose",
+      "command": "choose-client",
+      "scope": null,
+      "when": "kind is client",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:250",
+          "has": [
+            "my %commands = tree => 'choose-tree', client => 'choose-client',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.choose",
+      "command": "choose-client",
+      "scope": null,
+      "when": "kind is client",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:250",
+          "has": [
+            "my %commands = tree => 'choose-tree', client => 'choose-client',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.choose",
+      "command": "choose-buffer",
+      "scope": null,
+      "when": "kind is buffer",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:251",
+          "has": [
+            "buffer => 'choose-buffer', customize => 'customize-mode';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.choose",
+      "command": "choose-buffer",
+      "scope": null,
+      "when": "kind is buffer",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:251",
+          "has": [
+            "buffer => 'choose-buffer', customize => 'customize-mode';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.choose",
+      "command": "customize-mode",
+      "scope": null,
+      "when": "kind is customize",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:251",
+          "has": [
+            "buffer => 'choose-buffer', customize => 'customize-mode';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.choose",
+      "command": "customize-mode",
+      "scope": null,
+      "when": "kind is customize",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:265",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.choose"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:251",
+          "has": [
+            "buffer => 'choose-buffer', customize => 'customize-mode';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.find-window",
+      "command": "find-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:283",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.find-window"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:275",
+          "has": [
+            "my @argv = 'find-window', '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.find-window",
+      "command": "find-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:283",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.find-window"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:275",
+          "has": [
+            "my @argv = 'find-window', '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.display-panes-async",
+      "command": "display-panes",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:295",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.display-panes-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:291",
+          "has": [
+            "my @argv = 'display-panes', '-t', self!target;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.display-panes-async",
+      "command": "display-panes",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:295",
+          "has": [
+            "self!run(Invocation.new(:argv(@argv)), :$timeout-ms, |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.display-panes-async"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:291",
+          "has": [
+            "my @argv = 'display-panes', '-t', self!target;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.refresh",
+      "command": "refresh-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:309",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.refresh"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:306",
+          "has": [
+            "my @argv = 'refresh-client', '-t', self!target;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.refresh",
+      "command": "refresh-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:309",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.refresh"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:306",
+          "has": [
+            "my @argv = 'refresh-client', '-t', self!target;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.detach",
+      "command": "detach-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:314",
+          "has": [
+            "await self!run(Invocation.new(:argv(['detach-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.detach"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.detach",
+      "command": "detach-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:314",
+          "has": [
+            "await self!run(Invocation.new(:argv(['detach-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.detach"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.suspend",
+      "command": "suspend-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:319",
+          "has": [
+            "await self!run(Invocation.new(:argv(['suspend-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.suspend"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.suspend",
+      "command": "suspend-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:319",
+          "has": [
+            "await self!run(Invocation.new(:argv(['suspend-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.suspend"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.lock",
+      "command": "lock-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:324",
+          "has": [
+            "await self!run(Invocation.new(:argv(['lock-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.lock"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.lock",
+      "command": "lock-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:324",
+          "has": [
+            "await self!run(Invocation.new(:argv(['lock-client', '-t', self!target])), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.lock"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.switch",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:333",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.switch"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:330",
+          "has": [
+            "my @argv = 'switch-client', '-c', self!target, '-t', $session;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.switch",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:333",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.switch"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:330",
+          "has": [
+            "my @argv = 'switch-client', '-c', self!target, '-t', $session;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.key-table",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:339",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target,"
+          ],
+          "in": "LibTmux::Client::ClientTarget.key-table"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.key-table",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:339",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target,"
+          ],
+          "in": "LibTmux::Model::ClientRef.key-table"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.switch-relative",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:348",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target,"
+          ],
+          "in": "LibTmux::Client::ClientTarget.switch-relative"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.switch-relative",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:348",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target,"
+          ],
+          "in": "LibTmux::Model::ClientRef.switch-relative"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.toggle-read-only",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:354",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target, '-r', '-E', '-Z'])),"
+          ],
+          "in": "LibTmux::Client::ClientTarget.toggle-read-only"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.toggle-read-only",
+      "command": "switch-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:354",
+          "has": [
+            "await self!run(Invocation.new(:argv(['switch-client', '-c', self!target, '-r', '-E', '-Z'])),"
+          ],
+          "in": "LibTmux::Model::ClientRef.toggle-read-only"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.prompt-history",
+      "command": "show-prompt-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:362",
+          "has": [
+            "(await self!run(Invocation.new(:argv(@argv)), |%operation)).stdout"
+          ],
+          "in": "LibTmux::Client::ClientTarget.prompt-history"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:360",
+          "has": [
+            "my @argv = 'show-prompt-history';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.prompt-history",
+      "command": "show-prompt-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:362",
+          "has": [
+            "(await self!run(Invocation.new(:argv(@argv)), |%operation)).stdout"
+          ],
+          "in": "LibTmux::Model::ClientRef.prompt-history"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:360",
+          "has": [
+            "my @argv = 'show-prompt-history';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Client::ClientTarget.clear-prompt-history",
+      "command": "clear-prompt-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:369",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Client::ClientTarget.clear-prompt-history"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:367",
+          "has": [
+            "my @argv = 'clear-prompt-history';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.clear-prompt-history",
+      "command": "clear-prompt-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:369",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ],
+          "in": "LibTmux::Model::ClientRef.clear-prompt-history"
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:367",
+          "has": [
+            "my @argv = 'clear-prompt-history';"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.entries",
+      "command": "show-options",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:196",
+          "has": [
+            "self!execute(@argv, :decode(-> $result {"
+          ],
+          "in": "LibTmux::Configuration::Options.entries"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:193",
+          "has": [
+            "my @argv = 'show-options', |self!scope-flags;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.set",
+      "command": "set-option",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:243",
+          "has": [
+            "self!execute(['set-option', |self!scope-flags, '--', $key, $argument])"
+          ],
+          "in": "LibTmux::Configuration::Options.set"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.unset",
+      "command": "set-option",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:250",
+          "has": [
+            "self!execute(['set-option', |self!scope-flags, '-u', '--',"
+          ],
+          "in": "LibTmux::Configuration::Options.unset"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.set-raw",
+      "command": "set-option",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:256",
+          "has": [
+            "self!execute(['set-option', |self!scope-flags, '--', literal-format($name), $value])"
+          ],
+          "in": "LibTmux::Configuration::Options.set-raw"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.get-raw",
+      "command": "show-options",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:261",
+          "has": [
+            "self!execute(['show-options', |self!scope-flags, '-v', '--', literal-format($name)]).stdout"
+          ],
+          "in": "LibTmux::Configuration::Options.get-raw"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Environment.list",
+      "command": "show-environment",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:361",
+          "has": [
+            "self!execute(@argv, :decode(-> $result {"
+          ],
+          "in": "LibTmux::Configuration::Environment.list"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:359",
+          "has": [
+            "my @argv = 'show-environment', '-s', |self!flags;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Environment.get",
+      "command": "show-environment",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:379",
+          "has": [
+            "self!execute(@argv, :decode(-> $result {"
+          ],
+          "in": "LibTmux::Configuration::Environment.get"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:376",
+          "has": [
+            "my @argv = 'show-environment', '-s', |self!flags;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Environment.set",
+      "command": "set-environment",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:392",
+          "has": [
+            "self!execute(@argv)"
+          ],
+          "in": "LibTmux::Configuration::Environment.set"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:389",
+          "has": [
+            "my @argv = 'set-environment', |self!flags;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Environment.unset",
+      "command": "set-environment",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:397",
+          "has": [
+            "self!execute(['set-environment', |self!flags, '-u', '--', $name])"
+          ],
+          "in": "LibTmux::Configuration::Environment.unset"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Environment.remove",
+      "command": "set-environment",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:402",
+          "has": [
+            "self!execute(['set-environment', |self!flags, '-r', '--', $name])"
+          ],
+          "in": "LibTmux::Configuration::Environment.remove"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.list",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:429",
+          "has": [
+            "$runtime.read($projection, Invocation.new(:argv(['list-buffers'])),"
+          ],
+          "in": "LibTmux::Configuration::Buffers.list"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.get",
+      "command": "save-buffer",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:440",
+          "has": [
+            "self!execute(['save-buffer', '-b', $name, '-']).stdout"
+          ],
+          "in": "LibTmux::Configuration::Buffers.get"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.put",
+      "command": "load-buffer",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:445",
+          "has": [
+            "self!execute(['load-buffer', '-b', $name, '-'], :stdin($bytes))"
+          ],
+          "in": "LibTmux::Configuration::Buffers.put"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.delete",
+      "command": "delete-buffer",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:450",
+          "has": [
+            "self!execute(['delete-buffer', '-b', $name])"
+          ],
+          "in": "LibTmux::Configuration::Buffers.delete"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.rename",
+      "command": "set-buffer",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:455",
+          "has": [
+            "self!execute(['set-buffer', '-b', $name, '-n', $new-name])"
+          ],
+          "in": "LibTmux::Configuration::Buffers.rename"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Buffers.paste",
+      "command": "paste-buffer",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:465",
+          "has": [
+            "self!execute(@argv)"
+          ],
+          "in": "LibTmux::Configuration::Buffers.paste"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:461",
+          "has": [
+            "my @argv = 'paste-buffer', '-b', $name, '-t', $pane;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Hooks.list",
+      "command": "show-hooks",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:488",
+          "has": [
+            "self!execute(@argv, :decode(-> $result {"
+          ],
+          "in": "LibTmux::Configuration::Hooks.list"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:486",
+          "has": [
+            "my @argv = 'show-hooks', |self!scope-flags;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Hooks.set",
+      "command": "set-hook",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:496",
+          "has": [
+            "self!execute(['set-hook', |self!scope-flags, '--', \"$name\\[$index]\", $command.source])"
+          ],
+          "in": "LibTmux::Configuration::Hooks.set"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Hooks.append",
+      "command": "set-hook",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:501",
+          "has": [
+            "self!execute(['set-hook', |self!scope-flags, '-a', '--', $name, $command.source])"
+          ],
+          "in": "LibTmux::Configuration::Hooks.append"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Hooks.unset",
+      "command": "set-hook",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:506",
+          "has": [
+            "self!execute(['set-hook', |self!scope-flags, '-u', '--',"
+          ],
+          "in": "LibTmux::Configuration::Hooks.unset"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Hooks.run",
+      "command": "set-hook",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:512",
+          "has": [
+            "self!execute(['set-hook', |self!scope-flags, '-R', '--', $name])"
+          ],
+          "in": "LibTmux::Configuration::Hooks.run"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::KeyBindings.bind",
+      "command": "bind-key",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:551",
+          "has": [
+            "self!execute(@argv)"
+          ],
+          "in": "LibTmux::Configuration::KeyBindings.bind"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:547",
+          "has": [
+            "my @argv = 'bind-key', '-T', $table;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::KeyBindings.unbind",
+      "command": "unbind-key",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:556",
+          "has": [
+            "self!execute(['unbind-key', '-T', $table, '--', $key])"
+          ],
+          "in": "LibTmux::Configuration::KeyBindings.unbind"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::KeyBindings.clear",
+      "command": "unbind-key",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:561",
+          "has": [
+            "self!execute(['unbind-key', '-a', '-T', $table])"
+          ],
+          "in": "LibTmux::Configuration::KeyBindings.clear"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::KeyBindings.list",
+      "command": "list-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:570",
+          "has": [
+            "$runtime.read($projection, Invocation.new(:argv(['list-keys', '-T', $table])),"
+          ],
+          "in": "LibTmux::Configuration::KeyBindings.list"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:578",
+          "has": [
+            "self!execute(['list-keys', '-T', $table], :decode(-> $result {"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.rename",
+      "command": "rename-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:132",
+          "has": [
+            "self.command(Invocation.new(:argv(['rename-session', '-t', self.id, '--', literal-format($literal)])))"
+          ],
+          "in": "LibTmux::Model::SessionRef.rename"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.new-window",
+      "command": "new-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:149",
+          "has": [
+            "my $id = created-id(self.command(Invocation.new(:@argv)).stdout, 'window');"
+          ],
+          "in": "LibTmux::Model::SessionRef.new-window"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:142",
+          "has": [
+            "my @argv = 'new-window', '-P', '-F', creation-format('window'),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.next-window",
+      "command": "next-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:154",
+          "has": [
+            "self.command(Invocation.new(:argv(['next-window', '-t', self.id, |($activity ?? ['-a'] !! [])])))"
+          ],
+          "in": "LibTmux::Model::SessionRef.next-window"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.previous-window",
+      "command": "previous-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:158",
+          "has": [
+            "self.command(Invocation.new(:argv(['previous-window', '-t', self.id, |($activity ?? ['-a'] !! [])])))"
+          ],
+          "in": "LibTmux::Model::SessionRef.previous-window"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.last-window",
+      "command": "last-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:161",
+          "has": [
+            "method last-window(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['last-window', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::SessionRef.last-window"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.renumber-windows",
+      "command": "move-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:163",
+          "has": [
+            "method renumber-windows(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['move-window', '-r', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::SessionRef.renumber-windows"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.lock",
+      "command": "lock-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:165",
+          "has": [
+            "method lock(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['lock-session', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::SessionRef.lock"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.detach-clients",
+      "command": "detach-client",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:167",
+          "has": [
+            "method detach-clients(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['detach-client', '-s', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::SessionRef.detach-clients"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.kill",
+      "command": "kill-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:169",
+          "has": [
+            "method kill(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['kill-session', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::SessionRef.kill"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.rename",
+      "command": "rename-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:176",
+          "has": [
+            "self.command(Invocation.new(:argv(['rename-window', '-t', self.id, '--', literal-format($literal)])))"
+          ],
+          "in": "LibTmux::Model::WindowRef.rename"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.resize",
+      "command": "resize-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:180",
+          "has": [
+            "self.command(Invocation.new(:argv(['resize-window', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::WindowRef.resize"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.select-layout",
+      "command": "select-layout",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:190",
+          "has": [
+            "self.command(Invocation.new(:argv(['select-layout', '-t', self.id, $name])))"
+          ],
+          "in": "LibTmux::Model::WindowRef.select-layout"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.restore-layout",
+      "command": "select-layout",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:197",
+          "has": [
+            "self.command(Invocation.new(:argv(['select-layout', '-t', self.id, $layout.decode('utf8')])))"
+          ],
+          "in": "LibTmux::Model::WindowRef.restore-layout"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.next-layout",
+      "command": "next-layout",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:200",
+          "has": [
+            "method next-layout(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['next-layout', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::WindowRef.next-layout"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.previous-layout",
+      "command": "previous-layout",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:202",
+          "has": [
+            "method previous-layout(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['previous-layout', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::WindowRef.previous-layout"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.spread-layout",
+      "command": "select-layout",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:204",
+          "has": [
+            "method spread-layout(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['select-layout', '-E', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::WindowRef.spread-layout"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.last-pane",
+      "command": "last-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:206",
+          "has": [
+            "method last-pane(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['last-pane', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::WindowRef.last-pane"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.rotate",
+      "command": "rotate-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:209",
+          "has": [
+            "self.command(Invocation.new(:argv(['rotate-window', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::WindowRef.rotate"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.respawn",
+      "command": "respawn-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:215",
+          "has": [
+            "self.command(Invocation.new(:argv(['respawn-window', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::WindowRef.respawn"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.link",
+      "command": "link-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:232",
+          "has": [
+            "$runtime.execute(Invocation.new(:argv(['link-window', '-s', $source.value('session-id') ~ ':' ~ self.id,"
+          ],
+          "in": "LibTmux::Model::WindowRef.link"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.kill",
+      "command": "kill-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:239",
+          "has": [
+            "method kill(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['kill-window', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::WindowRef.kill"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.send-text",
+      "command": "send-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:245",
+          "has": [
+            "self.command(Invocation.new(:argv(['send-keys', '-l', '-t', self.id, '--', $text])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.send-text"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.send-keys",
+      "command": "send-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:250",
+          "has": [
+            "self.command(Invocation.new(:argv(['send-keys', '-t', self.id, '-N', $repeat.Str, '--', |@keys])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.send-keys"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.send-prefix",
+      "command": "send-prefix",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:254",
+          "has": [
+            "self.command(Invocation.new(:argv(['send-prefix', '-t', self.id, |($secondary ?? ['-2'] !! [])])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.send-prefix"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.capture",
+      "command": "capture-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:271",
+          "has": [
+            "self.command(Invocation.new(:@argv)).stdout"
+          ],
+          "in": "LibTmux::Model::PaneRef.capture"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:262",
+          "has": [
+            "my @argv = 'capture-pane', '-p', '-t', self.id;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.capture-pending",
+      "command": "capture-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:275",
+          "has": [
+            "self.command(Invocation.new(:argv(['capture-pane', '-p', '-P', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.capture-pending"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.split",
+      "command": "split-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:294",
+          "has": [
+            "my $id = created-id(self.command(Invocation.new(:@argv)).stdout, 'pane');"
+          ],
+          "in": "LibTmux::Model::PaneRef.split"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:287",
+          "has": [
+            "my @argv = 'split-window', '-P', '-F', creation-format('pane'), '-t', self.id;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.new-floating",
+      "command": "new-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:312",
+          "has": [
+            "my $id = created-id(self.command(Invocation.new(:@argv)).stdout, 'pane');"
+          ],
+          "in": "LibTmux::Model::PaneRef.new-floating"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:305",
+          "has": [
+            "my @argv = 'new-pane', '-P', '-F', creation-format('pane'), '-t', self.id,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.resize",
+      "command": "resize-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:317",
+          "has": [
+            "self.command(Invocation.new(:argv(['resize-pane', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.resize"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.toggle-zoom",
+      "command": "resize-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:321",
+          "has": [
+            "method toggle-zoom(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['resize-pane', '-Z', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.toggle-zoom"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.select",
+      "command": "select-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:324",
+          "has": [
+            "self.command(Invocation.new(:argv(['select-pane', '-t', self.id, |($preserve-zoom ?? ['-Z'] !! [])])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.select"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.set-title",
+      "command": "select-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:328",
+          "has": [
+            "self.command(Invocation.new(:argv(['select-pane', '-t', self.id, '-T', literal-format($title)])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.set-title"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.set-input",
+      "command": "select-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:332",
+          "has": [
+            "self.command(Invocation.new(:argv(['select-pane', '-t', self.id, $enabled ?? '-e' !! '-d'])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.set-input"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.toggle-mark",
+      "command": "select-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:335",
+          "has": [
+            "method toggle-mark(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['select-pane', '-m', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.toggle-mark"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.unmark",
+      "command": "select-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:337",
+          "has": [
+            "method unmark(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['select-pane', '-M', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.unmark"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.respawn",
+      "command": "respawn-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:341",
+          "has": [
+            "self.command(Invocation.new(:argv(['respawn-pane', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.respawn"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.join",
+      "command": "join-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:357",
+          "has": [
+            "self!transfer('join-pane', $target, :$horizontal, :$before, :$full, :$select, :$size, :$percent)"
+          ],
+          "in": "LibTmux::Model::PaneRef.join"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:348",
+          "has": [
+            "invalid-argument('Source and target pane must differ') if self.id eq $target.id;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.move",
+      "command": "move-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:363",
+          "has": [
+            "self!transfer('move-pane', $target, :$horizontal, :$before, :$full, :$select, :$size, :$percent)"
+          ],
+          "in": "LibTmux::Model::PaneRef.move"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:348",
+          "has": [
+            "invalid-argument('Source and target pane must differ') if self.id eq $target.id;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.move-floating",
+      "command": "move-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:369",
+          "has": [
+            "self.command(Invocation.new(:argv(['move-pane', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.move-floating"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.stack",
+      "command": "move-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:377",
+          "has": [
+            "self.command(Invocation.new(:argv(['move-pane', '-t', self.id, '-P', $placement])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.stack"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.set-z-index",
+      "command": "move-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:382",
+          "has": [
+            "self.command(Invocation.new(:argv(['move-pane', '-t', self.id, '-z', $index.Str])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.set-z-index"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.tile",
+      "command": "move-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:387",
+          "has": [
+            "self.command(Invocation.new(:argv(['move-pane', '-s', self.id, '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.tile"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.float",
+      "command": "break-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:394",
+          "has": [
+            "self.command(Invocation.new(:argv(['break-pane', '-W', '-s', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.float"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.swap",
+      "command": "swap-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:402",
+          "has": [
+            "self.command(Invocation.new(:argv(['swap-pane', '-s', self.id, '-t', $target.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.swap"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.break",
+      "command": "break-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:447",
+          "has": [
+            "my $output = $runtime.execute(Invocation.new(:@argv),"
+          ],
+          "in": "LibTmux::Model::PaneRef.break"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:417",
+          "has": [
+            "my @argv = 'break-pane', '-P', '-F', creation-format('window'),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.clear-history",
+      "command": "clear-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:465",
+          "has": [
+            "method clear-history(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['clear-history', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.clear-history"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.reset-terminal",
+      "command": "send-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:467",
+          "has": [
+            "method reset-terminal(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['send-keys', '-R', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.reset-terminal"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.reset",
+      "command": "send-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:472",
+          "has": [
+            "self.command(Invocation.new(:argv(['if-shell', '-F', '1',"
+          ],
+          "in": "LibTmux::Model::PaneRef.reset"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:470",
+          "has": [
+            "my $reset = Invocation.new(:argv(['send-keys', '-R', '-t', self.id]));"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.reset",
+      "command": "clear-history",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:472",
+          "has": [
+            "self.command(Invocation.new(:argv(['if-shell', '-F', '1',"
+          ],
+          "in": "LibTmux::Model::PaneRef.reset"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:471",
+          "has": [
+            "my $history = Invocation.new(:argv(['clear-history', '-t', self.id]));"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.reset",
+      "command": "if-shell",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:472",
+          "has": [
+            "self.command(Invocation.new(:argv(['if-shell', '-F', '1',"
+          ],
+          "in": "LibTmux::Model::PaneRef.reset"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.copy-mode",
+      "command": "copy-mode",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:477",
+          "has": [
+            "self.command(Invocation.new(:argv(['copy-mode', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.copy-mode"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.copy-command",
+      "command": "send-keys",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:482",
+          "has": [
+            "self.command(Invocation.new(:argv(['send-keys', '-X', '-t', self.id, '--', $command, |@arguments])))"
+          ],
+          "in": "LibTmux::Model::PaneRef.copy-command"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.clock-mode",
+      "command": "clock-mode",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:485",
+          "has": [
+            "method clock-mode(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['clock-mode', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.clock-mode"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.pipe",
+      "command": "pipe-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:490",
+          "has": [
+            "self.command(Invocation.new(:argv(['pipe-pane', '-t', self.id,"
+          ],
+          "in": "LibTmux::Model::PaneRef.pipe"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.kill",
+      "command": "kill-pane",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:495",
+          "has": [
+            "method kill(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['kill-pane', '-t', self.id]))) }"
+          ],
+          "in": "LibTmux::Model::PaneRef.kill"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowLinkRef.select",
+      "command": "select-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:533",
+          "has": [
+            "$runtime.execute(Invocation.new(:argv(['select-window', '-t', self.target])),"
+          ],
+          "in": "LibTmux::Model::WindowLinkRef.select"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowLinkRef.unlink",
+      "command": "unlink-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:540",
+          "has": [
+            "$runtime.execute(Invocation.new(:argv(['unlink-window', '-t', self.target,"
+          ],
+          "in": "LibTmux::Model::WindowLinkRef.unlink"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowLinkRef.move",
+      "command": "move-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:549",
+          "has": [
+            "$runtime.execute(Invocation.new(:argv(['move-window', '-s', self.target,"
+          ],
+          "in": "LibTmux::Model::WindowLinkRef.move"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowLinkRef.swap",
+      "command": "swap-window",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:561",
+          "has": [
+            "$runtime.execute(Invocation.new(:argv(['swap-window', '-s', self.target,"
+          ],
+          "in": "LibTmux::Model::WindowLinkRef.swap"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.run-shell-async",
+      "command": "run-shell",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:487",
+          "has": [
+            "self!request({"
+          ],
+          "in": "LibTmux::Server.run-shell-async"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:489",
+          "has": [
+            "['run-shell', |(argument-bool($background, 'background') ?? ['-b'] !! []),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.if-shell",
+      "command": "if-shell",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:498",
+          "has": [
+            "await self!request({"
+          ],
+          "in": "LibTmux::Server.if-shell"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:504",
+          "has": [
+            "['if-shell', |($format ?? ['-F'] !! []),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.source-file",
+      "command": "source-file",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:514",
+          "has": [
+            "await self!request({"
+          ],
+          "in": "LibTmux::Server.source-file"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:519",
+          "has": [
+            "['source-file', |(argument-bool($parse-only, 'parse-only') ?? ['-n'] !! []), '--', $literal]"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.wait-for-async",
+      "command": "wait-for",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:528",
+          "has": [
+            "self!request({"
+          ],
+          "in": "LibTmux::Server.wait-for-async"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:533",
+          "has": [
+            "['wait-for', |%flags{$action}, '--', $name]"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.kill-server",
+      "command": "kill-server",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:539",
+          "has": [
+            "await self!request({ ['kill-server'] }, :$cancel)"
+          ],
+          "in": "LibTmux::Server.kill-server"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.new-session",
+      "command": "new-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:455",
+          "has": [
+            "created($!runtime, self!observation($deadline), $command, :$deadline)"
+          ],
+          "in": "LibTmux::Server.new-session"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:453",
+          "has": [
+            "my $command = creation($name, $shell-command, $width, $height);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:65",
+          "has": [
+            "my @argv = 'new-session', '-d', '-P', '-F', 'LTM1-session-#{session_id}',"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:72",
+          "has": [
+            "my $result = $runtime.execute($command, :incarnation($observation.incarnation), :$cancel, :$deadline);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.start",
+      "command": "new-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:665",
+          "has": [
+            "{ LEAVE $creator.close; created($creator, $observation, $command, :$cancel, :$deadline) }"
+          ],
+          "in": "LibTmux::Server.start"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:626",
+          "has": [
+            "my $command = creation($name, $shell-command, $width, $height);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:65",
+          "has": [
+            "my @argv = 'new-session', '-d', '-P', '-F', 'LTM1-session-#{session_id}',"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:72",
+          "has": [
+            "my $result = $runtime.execute($command, :incarnation($observation.incarnation), :$cancel, :$deadline);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.run-shell",
+      "command": "run-shell",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:483",
+          "has": [
+            "method run-shell(Mu $script, *%options --> Result:D) is single-operation { await self.run-shell-async($script, |%options) }"
+          ],
+          "in": "LibTmux::Server.run-shell"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:487",
+          "has": [
+            "self!request({"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:489",
+          "has": [
+            "['run-shell', |(argument-bool($background, 'background') ?? ['-b'] !! []),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:478",
+          "has": [
+            "$!runtime.execute($command, :incarnation($identity), :$cancel, :$deadline)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.wait-for",
+      "command": "wait-for",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:524",
+          "has": [
+            "method wait-for(Mu $channel, *%options --> Result:D) is single-operation { await self.wait-for-async($channel, |%options) }"
+          ],
+          "in": "LibTmux::Server.wait-for"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:528",
+          "has": [
+            "self!request({"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:533",
+          "has": [
+            "['wait-for', |%flags{$action}, '--', $name]"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:478",
+          "has": [
+            "$!runtime.execute($command, :incarnation($identity), :$cancel, :$deadline)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Configuration::Options.get",
+      "command": "show-options",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:206",
+          "has": [
+            "my @entries = self.entries(:$name, :$effective);"
+          ],
+          "in": "LibTmux::Configuration::Options.get"
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:193",
+          "has": [
+            "my @argv = 'show-options', |self!scope-flags;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:196",
+          "has": [
+            "self!execute(@argv, :decode(-> $result {"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:375",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Server.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:375",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Server.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:375",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Server.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:375",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Server.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:375",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Server.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot-async",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot-async",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot-async",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot-async",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.snapshot-async",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:379",
+          "has": [
+            "capture($!runtime, :required-incarnation($!owned-incarnation), :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:477",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:477",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:477",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:477",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:477",
+          "has": [
+            "method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D) is single-operation { await self.snapshot-async(:$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot-async",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot-async",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot-async",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot-async",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.snapshot-async",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:481",
+          "has": [
+            "start { capture(self, :required-incarnation($!observation.incarnation), :$deadline, :$cancel) }"
+          ],
+          "in": "LibTmux::Control::Connection.snapshot-async"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.inspect",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:577",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation(self.incarnation));"
+          ],
+          "in": "LibTmux::Model::ClientRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.inspect",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:577",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation(self.incarnation));"
+          ],
+          "in": "LibTmux::Model::ClientRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.inspect",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:577",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation(self.incarnation));"
+          ],
+          "in": "LibTmux::Model::ClientRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.inspect",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:577",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation(self.incarnation));"
+          ],
+          "in": "LibTmux::Model::ClientRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::ClientRef.inspect",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:577",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation(self.incarnation));"
+          ],
+          "in": "LibTmux::Model::ClientRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.inspect",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::PaneRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.inspect",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::PaneRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.inspect",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::PaneRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.inspect",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::PaneRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.inspect",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::PaneRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.inspect",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::SessionRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.inspect",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::SessionRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.inspect",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::SessionRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.inspect",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::SessionRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::SessionRef.inspect",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::SessionRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.inspect",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::WindowRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.inspect",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::WindowRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.inspect",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::WindowRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.inspect",
+      "command": "list-clients",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::WindowRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.inspect",
+      "command": "list-buffers",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:107",
+          "has": [
+            "my $snapshot = capture($runtime, :required-incarnation($!incarnation));"
+          ],
+          "in": "LibTmux::Model::WindowRef.inspect"
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "session/group query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ],
+          "in": "LibTmux::Server.query"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "window/link query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ],
+          "in": "LibTmux::Server.query"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "pane query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ],
+          "in": "LibTmux::Server.query"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query",
+      "command": "list-clients",
+      "scope": null,
+      "when": "client query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ],
+          "in": "LibTmux::Server.query"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "buffer query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ],
+          "in": "LibTmux::Server.query"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-async",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "session/group query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-async",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "window/link query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-async",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "pane query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-async",
+      "command": "list-clients",
+      "scope": null,
+      "when": "client query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-async",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "buffer query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Server.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-panes",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:430",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-panes",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:430",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-panes",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:430",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-panes",
+      "command": "list-clients",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:430",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-panes",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:430",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-sessions",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-sessions"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-sessions",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-sessions"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-sessions",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-sessions"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-sessions",
+      "command": "list-clients",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-sessions"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-sessions",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-sessions"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-windows",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:436",
+          "has": [
+            "method query-windows(*%options --> WindowSelection:D) { self.query('window', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-windows"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-windows",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:436",
+          "has": [
+            "method query-windows(*%options --> WindowSelection:D) { self.query('window', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-windows"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-windows",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:436",
+          "has": [
+            "method query-windows(*%options --> WindowSelection:D) { self.query('window', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-windows"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-windows",
+      "command": "list-clients",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:436",
+          "has": [
+            "method query-windows(*%options --> WindowSelection:D) { self.query('window', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-windows"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-windows",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:436",
+          "has": [
+            "method query-windows(*%options --> WindowSelection:D) { self.query('window', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-windows"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-window-links",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-window-links"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-window-links",
+      "command": "list-windows",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-window-links"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-window-links",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-window-links"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-window-links",
+      "command": "list-clients",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-window-links"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.query-window-links",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ],
+          "in": "LibTmux::Server.query-window-links"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "session/group query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "window/link query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "pane query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query",
+      "command": "list-clients",
+      "scope": null,
+      "when": "client query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "buffer query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-async",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "session/group query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Control::Connection.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-async",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "window/link query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Control::Connection.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-async",
+      "command": "list-panes",
+      "scope": "server",
+      "when": "pane query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Control::Connection.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-async",
+      "command": "list-clients",
+      "scope": null,
+      "when": "client query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Control::Connection.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-async",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "buffer query or full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ],
+          "in": "LibTmux::Control::Connection.query-async"
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-panes",
+      "command": "list-sessions",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:511",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:991",
+          "has": [
+            "my %commands = session => ['list-sessions'], window-link => ['list-windows', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-panes",
+      "command": "list-windows",
+      "scope": "server",
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:511",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:217",
+          "has": [
+            "window => ['list-windows', '-a'], window-link => ['list-windows', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-panes",
+      "command": "list-panes",
+      "scope": "server",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:511",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:992",
+          "has": [
+            "window => ['list-windows', '-a'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-panes",
+      "command": "list-clients",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:511",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.query-panes",
+      "command": "list-buffers",
+      "scope": null,
+      "when": "relationship predicates require a full graph",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:511",
+          "has": [
+            "method query-panes(*%options --> PaneSelection:D) { self.query('pane', |%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.query-panes"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:491",
+          "has": [
+            "method query(Mu $entity, *%options --> Positional:D) { await self.query-async($entity, |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:507",
+          "has": [
+            "acquire-plan(self, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:36",
+          "has": [
+            "if $plan.complete-graph-required {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:37",
+          "has": [
+            "$snapshot = capture($source, :required-incarnation($observation.incarnation), :$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:218",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:1004",
+          "has": [
+            "%rows{$entity} = $runtime.read($projection,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:993",
+          "has": [
+            "client => ['list-clients'], buffer => ['list-buffers'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.has-session",
+      "command": "list-sessions",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:449",
+          "has": [
+            "so self.query-sessions(:where(%where)).elems"
+          ],
+          "in": "LibTmux::Server.has-session"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:434",
+          "has": [
+            "method query-sessions(*%options --> SessionSelection:D) { self.query('session', |%options) }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:405",
+          "has": [
+            "await self.query-async($entity, |%options)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:426",
+          "has": [
+            "acquire-plan($!runtime, $plan, :$deadline, :$cancel)"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Execution.rakumod:39",
+          "has": [
+            "my $rows = $source.read($plan.projection, $plan.candidate-command,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Query/Plan.rakumod:216",
+          "has": [
+            "my %listings = session => ['list-sessions'], pane => ['list-panes', '-a'],"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Attachment.spawn",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:86",
+          "has": [
+            "$owner!launch($guard, $deadline, $cancel);"
+          ],
+          "in": "LibTmux::Attachment.spawn"
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:74",
+          "has": [
+            "my @argv = 'attach-session', '-t', $session;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:112",
+          "has": [
+            "$!process = Proc::Async.new(|$!endpoint.argv, '-N', |$command.as-argv);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Attachment.spawn",
+      "command": "list-sessions",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:70",
+          "has": [
+            "my @sessions = $runtime.read($projection, Invocation.new(:argv(['list-sessions'])),"
+          ],
+          "in": "LibTmux::Attachment.spawn"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Attachment.inspect-client",
+      "command": "list-clients",
+      "scope": null,
+      "when": "the child has not exited",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:202",
+          "has": [
+            "my @rows = $runtime.read($projection, Invocation.new(:argv(['list-clients'])),"
+          ],
+          "in": "LibTmux::Attachment.inspect-client"
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:197",
+          "has": [
+            "return Nil if self.state == AttachmentExited;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.connect",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:160",
+          "has": [
+            "method connect(*%options --> LibTmux::Control::Connection:D) is single-operation { await self.connect-async(|%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.connect"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:229",
+          "has": [
+            "$!proc = Proc::Async.new(:w, |$!endpoint.argv,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:230",
+          "has": [
+            "'-N', '-C', 'attach-session', '-f', 'ignore-size', '-t', $!session-id);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.connect",
+      "command": "refresh-client",
+      "scope": null,
+      "when": "new-layouts negotiation is enabled",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:160",
+          "has": [
+            "method connect(*%options --> LibTmux::Control::Connection:D) is single-operation { await self.connect-async(|%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.connect"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:202",
+          "has": [
+            "if $modern {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:203",
+          "has": [
+            "await $connection!submit(Invocation.new(:argv(['refresh-client', '-f', 'new-layouts'])),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.connect-async",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ],
+          "in": "LibTmux::Control::Connection.connect-async"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:229",
+          "has": [
+            "$!proc = Proc::Async.new(:w, |$!endpoint.argv,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:230",
+          "has": [
+            "'-N', '-C', 'attach-session', '-f', 'ignore-size', '-t', $!session-id);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.connect-async",
+      "command": "refresh-client",
+      "scope": null,
+      "when": "new-layouts negotiation is enabled",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ],
+          "in": "LibTmux::Control::Connection.connect-async"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:202",
+          "has": [
+            "if $modern {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:203",
+          "has": [
+            "await $connection!submit(Invocation.new(:argv(['refresh-client', '-f', 'new-layouts'])),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.open-control",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:576",
+          "has": [
+            "await self.open-control-async(:$session-id, |%settings)"
+          ],
+          "in": "LibTmux::Server.open-control"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:583",
+          "has": [
+            "LibTmux::Control::Connection.connect(:endpoint($!endpoint), :$session-id,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:229",
+          "has": [
+            "$!proc = Proc::Async.new(:w, |$!endpoint.argv,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:230",
+          "has": [
+            "'-N', '-C', 'attach-session', '-f', 'ignore-size', '-t', $!session-id);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.open-control",
+      "command": "refresh-client",
+      "scope": null,
+      "when": "new-layouts negotiation is enabled",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:576",
+          "has": [
+            "await self.open-control-async(:$session-id, |%settings)"
+          ],
+          "in": "LibTmux::Server.open-control"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:583",
+          "has": [
+            "LibTmux::Control::Connection.connect(:endpoint($!endpoint), :$session-id,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:202",
+          "has": [
+            "if $modern {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:203",
+          "has": [
+            "await $connection!submit(Invocation.new(:argv(['refresh-client', '-f', 'new-layouts'])),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.open-control-async",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:583",
+          "has": [
+            "LibTmux::Control::Connection.connect(:endpoint($!endpoint), :$session-id,"
+          ],
+          "in": "LibTmux::Server.open-control-async"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:229",
+          "has": [
+            "$!proc = Proc::Async.new(:w, |$!endpoint.argv,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:230",
+          "has": [
+            "'-N', '-C', 'attach-session', '-f', 'ignore-size', '-t', $!session-id);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.open-control-async",
+      "command": "refresh-client",
+      "scope": null,
+      "when": "new-layouts negotiation is enabled",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:583",
+          "has": [
+            "LibTmux::Control::Connection.connect(:endpoint($!endpoint), :$session-id,"
+          ],
+          "in": "LibTmux::Server.open-control-async"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:200",
+          "has": [
+            "$connection!launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:202",
+          "has": [
+            "if $modern {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:203",
+          "has": [
+            "await $connection!submit(Invocation.new(:argv(['refresh-client', '-f', 'new-layouts'])),"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.attach",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:592",
+          "has": [
+            "await self.attach-async(:$session, :$terminal, |%settings)"
+          ],
+          "in": "LibTmux::Server.attach"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:602",
+          "has": [
+            ":$session, :$terminal, :$read-only, :$detach-others, :$update-environment,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:86",
+          "has": [
+            "$owner!launch($guard, $deadline, $cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:74",
+          "has": [
+            "my @argv = 'attach-session', '-t', $session;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:112",
+          "has": [
+            "$!process = Proc::Async.new(|$!endpoint.argv, '-N', |$command.as-argv);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.attach-async",
+      "command": "attach-session",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:602",
+          "has": [
+            ":$session, :$terminal, :$read-only, :$detach-others, :$update-environment,"
+          ],
+          "in": "LibTmux::Server.attach-async"
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:86",
+          "has": [
+            "$owner!launch($guard, $deadline, $cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:74",
+          "has": [
+            "my @argv = 'attach-session', '-t', $session;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:112",
+          "has": [
+            "$!process = Proc::Async.new(|$!endpoint.argv, '-N', |$command.as-argv);"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.observe",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:463",
+          "has": [
+            "method observe(*%options --> Observation:D) is single-operation { await self.observe-async(|%options) }"
+          ],
+          "in": "LibTmux::Control::Connection.observe"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:471",
+          "has": [
+            "await self!submit(Invocation, :deadline($until), :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:365",
+          "has": [
+            "my $barrier = Invocation.new(:argv(['display-message', '-p',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Control::Connection.observe-async",
+      "command": "display-message",
+      "scope": null,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:471",
+          "has": [
+            "await self!submit(Invocation, :deadline($until), :$cancel);"
+          ],
+          "in": "LibTmux::Control::Connection.observe-async"
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:365",
+          "has": [
+            "my $barrier = Invocation.new(:argv(['display-message', '-p',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.capabilities",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:384",
+          "has": [
+            "await self.capabilities-async(:$cancel)"
+          ],
+          "in": "LibTmux::Server.capabilities"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.capabilities-async",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:388",
+          "has": [
+            "self!operation(-> $deadline { self!observation($deadline, :$cancel).capabilities })"
+          ],
+          "in": "LibTmux::Server.capabilities-async"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.explain",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:398",
+          "has": [
+            ":capabilities(self!observation($deadline).capabilities), :$pushdown);"
+          ],
+          "in": "LibTmux::Server.explain"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.explain-panes",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:432",
+          "has": [
+            "method explain-panes(*%options --> Plan:D) { self.explain('pane', |%options) }"
+          ],
+          "in": "LibTmux::Server.explain-panes"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:398",
+          "has": [
+            ":capabilities(self!observation($deadline).capabilities), :$pushdown);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.from-env",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:324",
+          "has": [
+            "my $observation = $server!observation($deadline);"
+          ],
+          "in": "LibTmux::Server.from-env"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.options",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:554",
+          "has": [
+            "self!configuration(LibTmux::Configuration::Options, :$scope, :global($scope ne 'server'))"
+          ],
+          "in": "LibTmux::Server.options"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:544",
+          "has": [
+            "$type.new(:endpoint($!endpoint), :incarnation(self!observation($deadline).incarnation),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.environment",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:558",
+          "has": [
+            "self!configuration(LibTmux::Configuration::Environment, :scope<session>, :global)"
+          ],
+          "in": "LibTmux::Server.environment"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:544",
+          "has": [
+            "$type.new(:endpoint($!endpoint), :incarnation(self!observation($deadline).incarnation),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.buffers",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:562",
+          "has": [
+            "self!configuration(LibTmux::Configuration::Buffers)"
+          ],
+          "in": "LibTmux::Server.buffers"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:544",
+          "has": [
+            "$type.new(:endpoint($!endpoint), :incarnation(self!observation($deadline).incarnation),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.hooks",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:567",
+          "has": [
+            "self!configuration(LibTmux::Configuration::Hooks, :$scope, :global)"
+          ],
+          "in": "LibTmux::Server.hooks"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:544",
+          "has": [
+            "$type.new(:endpoint($!endpoint), :incarnation(self!observation($deadline).incarnation),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Server.key-bindings",
+      "command": "run-shell",
+      "scope": null,
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:571",
+          "has": [
+            "self!configuration(LibTmux::Configuration::KeyBindings)"
+          ],
+          "in": "LibTmux::Server.key-bindings"
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:544",
+          "has": [
+            "$type.new(:endpoint($!endpoint), :incarnation(self!observation($deadline).incarnation),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:368",
+          "has": [
+            "my $observation = $!runtime.observe(:$deadline, :$cancel);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::WindowRef.link",
+      "command": "list-windows",
+      "scope": "server",
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:227",
+          "has": [
+            "my @links = $runtime.read($projection, Invocation.new(:argv(['list-windows', '-a'])),"
+          ],
+          "in": "LibTmux::Model::WindowRef.link"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.break",
+      "command": "list-panes",
+      "scope": "server",
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:427",
+          "has": [
+            "my @current = $runtime.read($pane-projection, Invocation.new(:argv(['list-panes', '-a'])),"
+          ],
+          "in": "LibTmux::Model::PaneRef.break"
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "symbol": "LibTmux::Model::PaneRef.break",
+      "command": "list-windows",
+      "scope": "server",
+      "incidental": true,
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:434",
+          "has": [
+            "my @links = $runtime.read($link-projection, Invocation.new(:argv(['list-windows', '-a'])),"
+          ],
+          "in": "LibTmux::Model::PaneRef.break"
+        }
+      ]
     }
   ]
 }
diff --git a/scripts/tmux-usage/guards.json b/scripts/tmux-usage/guards.json
index 66348b4fc..6017fd9cf 100644
--- a/scripts/tmux-usage/guards.json
+++ b/scripts/tmux-usage/guards.json
@@ -355,6 +355,46 @@
           ]
         }
       ]
+    },
+    {
+      "port": "raku",
+      "name": "!guard",
+      "owner": "Runtime",
+      "purpose": "Refuses a subprocess mutation when the daemon PID/start time differs from the retained incarnation.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Engine.rakumod:317",
+          "has": [
+            "method !guard(Invocation:D $command, Incarnation:D $incarnation, Str:D $refusal --> Invocation:D) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:321",
+          "has": [
+            "'if-shell', '-F', $condition, $command.source, $refusal,"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "name": "spawn",
+      "owner": "Attachment",
+      "purpose": "Refuses attachment when the daemon PID/start time differs from the retained incarnation.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:55",
+          "has": [
+            "method spawn(Endpoint:D :$endpoint!, Incarnation:D :$incarnation!,"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Attachment.rakumod:81",
+          "has": [
+            "my $guard = Invocation.new(:argv(['if-shell', '-F', $condition,"
+          ]
+        }
+      ]
     }
   ]
 }
diff --git a/scripts/tmux-usage/not-senders.json b/scripts/tmux-usage/not-senders.json
index 13464b19f..492c23cb4 100644
--- a/scripts/tmux-usage/not-senders.json
+++ b/scripts/tmux-usage/not-senders.json
@@ -5474,6 +5474,588 @@
           ]
         }
       ]
+    },
+    {
+      "port": "raku",
+      "owner": "ClientTarget",
+      "names": [
+        "clear-prompt-history"
+      ],
+      "commands": [
+        "clear-history"
+      ],
+      "kind": "other-command",
+      "why": "Clears prompt history with clear-prompt-history; pane scrollback is separate.",
+      "in": "lib/LibTmux/Client.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:367",
+          "has": [
+            "my @argv = 'clear-prompt-history';"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:369",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "ClientTarget",
+      "names": [
+        "find-window"
+      ],
+      "commands": [
+        "list-clients",
+        "list-windows"
+      ],
+      "kind": "other-command",
+      "why": "Opens find-window. list-clients is shared identity revalidation, not this method’s discovery operation.",
+      "in": "lib/LibTmux/Client.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:112",
+          "has": [
+            "my @clients = $runtime.read($projection, Invocation.new(:argv(['list-clients'])),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:275",
+          "has": [
+            "my @argv = 'find-window', '-t', $pane;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:283",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "ClientRef",
+      "names": [
+        "clear-prompt-history"
+      ],
+      "commands": [
+        "clear-history"
+      ],
+      "kind": "other-command",
+      "why": "Clears prompt history with clear-prompt-history; pane scrollback is separate.",
+      "in": "lib/LibTmux/Client.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:367",
+          "has": [
+            "my @argv = 'clear-prompt-history';"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:369",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), |%operation)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "ClientRef",
+      "names": [
+        "find-window"
+      ],
+      "commands": [
+        "list-clients",
+        "list-windows"
+      ],
+      "kind": "other-command",
+      "why": "Opens find-window. list-clients is shared identity revalidation, not this method’s discovery operation.",
+      "in": "lib/LibTmux/Client.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:112",
+          "has": [
+            "my @clients = $runtime.read($projection, Invocation.new(:argv(['list-clients'])),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:275",
+          "has": [
+            "my @argv = 'find-window', '-t', $pane;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:283",
+          "has": [
+            "await self!run(Invocation.new(:argv(@argv)), :$pane, |%operation)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Buffers",
+      "names": [
+        "get"
+      ],
+      "commands": [
+        "list-buffers",
+        "show-buffer"
+      ],
+      "kind": "other-command",
+      "why": "Reads exact buffer bytes with save-buffer to stdout.",
+      "in": "lib/LibTmux/Configuration.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Configuration.rakumod:440",
+          "has": [
+            "self!execute(['save-buffer', '-b', $name, '-']).stdout"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "ownerSuffix": "Selection",
+      "names": [
+        "list",
+        "List"
+      ],
+      "commands": [
+        "list-panes",
+        "list-windows",
+        "list-sessions",
+        "list-clients",
+        "list-buffers"
+      ],
+      "kind": "values",
+      "why": "Native List coercions return captured membership without acquiring daemon state.",
+      "in": "lib/LibTmux/Selection.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Selection.rakumod:43",
+          "has": [
+            "method list(--> List:D) { $!members.list }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Selection.rakumod:45",
+          "has": [
+            "method List(--> List:D) { $!members.List }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Pane",
+      "names": [
+        "new"
+      ],
+      "commands": [
+        "new-pane"
+      ],
+      "kind": "no-send",
+      "why": "Captured views reject public construction; acquisition creates their records internally.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:825",
+          "has": [
+            "method new(| --> Nil) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:826",
+          "has": [
+            "X::LibTmux::Command.new(:kind<argument>, :outcome(NotStarted),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:827",
+          "has": [
+            ":message('Obtain captured views from a Snapshot')).throw"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Session",
+      "names": [
+        "new"
+      ],
+      "commands": [
+        "new-session"
+      ],
+      "kind": "no-send",
+      "why": "Captured views reject public construction; acquisition creates their records internally.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:825",
+          "has": [
+            "method new(| --> Nil) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:826",
+          "has": [
+            "X::LibTmux::Command.new(:kind<argument>, :outcome(NotStarted),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:827",
+          "has": [
+            ":message('Obtain captured views from a Snapshot')).throw"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "SessionGroup",
+      "names": [
+        "new"
+      ],
+      "commands": [
+        "new-session"
+      ],
+      "kind": "no-send",
+      "why": "Captured views reject public construction; acquisition creates their records internally.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:825",
+          "has": [
+            "method new(| --> Nil) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:826",
+          "has": [
+            "X::LibTmux::Command.new(:kind<argument>, :outcome(NotStarted),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:827",
+          "has": [
+            ":message('Obtain captured views from a Snapshot')).throw"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Window",
+      "names": [
+        "new"
+      ],
+      "commands": [
+        "new-window"
+      ],
+      "kind": "no-send",
+      "why": "Captured views reject public construction; acquisition creates their records internally.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:825",
+          "has": [
+            "method new(| --> Nil) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:826",
+          "has": [
+            "X::LibTmux::Command.new(:kind<argument>, :outcome(NotStarted),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:827",
+          "has": [
+            ":message('Obtain captured views from a Snapshot')).throw"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "WindowLink",
+      "names": [
+        "new"
+      ],
+      "commands": [
+        "new-window"
+      ],
+      "kind": "no-send",
+      "why": "Captured views reject public construction; acquisition creates their records internally.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:825",
+          "has": [
+            "method new(| --> Nil) {"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:826",
+          "has": [
+            "X::LibTmux::Command.new(:kind<argument>, :outcome(NotStarted),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:827",
+          "has": [
+            ":message('Obtain captured views from a Snapshot')).throw"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Pane",
+      "names": [
+        "pipe"
+      ],
+      "commands": [
+        "pipe-pane"
+      ],
+      "kind": "values",
+      "why": "Reads the captured pipe flag without dispatching a command.",
+      "in": "lib/LibTmux/Fields.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Fields.rakumod:116",
+          "has": [
+            "method pipe(--> Bool:D) { self.value('pipe') }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "WindowLink",
+      "names": [
+        "last"
+      ],
+      "commands": [
+        "last-window"
+      ],
+      "kind": "values",
+      "why": "Reads the captured last-window flag without selecting a window.",
+      "in": "lib/LibTmux/Fields.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Fields.rakumod:40",
+          "has": [
+            "method last(--> Bool:D) { self.value('last') }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "PaneRef",
+      "names": [
+        "clear-history"
+      ],
+      "commands": [
+        "clear-prompt-history"
+      ],
+      "kind": "other-command",
+      "why": "Clears pane scrollback with clear-history; client prompt history is separate.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:465",
+          "has": [
+            "method clear-history(--> Result:D) is single-operation { self.command(Invocation.new(:argv(['clear-history', '-t', self.id]))) }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "PaneRef",
+      "names": [
+        "copy-command"
+      ],
+      "commands": [
+        "copy-mode"
+      ],
+      "kind": "other-command",
+      "why": "Dispatches a copy-mode action with send-keys -X without entering copy mode.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:482",
+          "has": [
+            "self.command(Invocation.new(:argv(['send-keys', '-X', '-t', self.id, '--', $command, |@arguments])))"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Session",
+      "names": [
+        "window-links"
+      ],
+      "commands": [
+        "link-window"
+      ],
+      "kind": "values",
+      "why": "Traverses captured window placements without creating a link.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:912",
+          "has": [
+            "method window-links(--> WindowLinkSelection:D) { self.relation('window-links') }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Snapshot",
+      "names": [
+        "window-links"
+      ],
+      "commands": [
+        "link-window"
+      ],
+      "kind": "values",
+      "why": "Traverses captured window placements without creating a link.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:681",
+          "has": [
+            "method window-links(--> WindowLinkSelection:D) { self.selection('window-link') }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Window",
+      "names": [
+        "links"
+      ],
+      "commands": [
+        "link-window"
+      ],
+      "kind": "values",
+      "why": "Traverses captured window placements without creating a link.",
+      "in": "lib/LibTmux/Model.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:930",
+          "has": [
+            "method links(--> WindowLinkSelection:D) { self.relation('links') }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Server",
+      "names": [
+        "close",
+        "close-async"
+      ],
+      "commands": [
+        "kill-server"
+      ],
+      "kind": "no-send",
+      "why": "Joins runtime work and stops an owned process through its pidfd; borrowed daemons remain running.",
+      "in": "lib/LibTmux/Server.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:685",
+          "has": [
+            "method close(--> Nil) { await self.close-async }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:695",
+          "has": [
+            "try { $!runtime.close; CATCH { default { $failure = $_ } } }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:697",
+          "has": [
+            "try { $!owner.stop if $!owner.defined; CATCH { default { $failure //= $_ } } }"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:171",
+          "has": [
+            "method signal(Int:D $signal --> Nil) {"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Server",
+      "names": [
+        "query-window-links"
+      ],
+      "commands": [
+        "link-window"
+      ],
+      "kind": "other-command",
+      "why": "Executes a window-link query; it does not create a placement.",
+      "in": "lib/LibTmux/Server.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:438",
+          "has": [
+            "method query-window-links(*%options --> WindowLinkSelection:D) { self.query('window-link', |%options) }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "owner": "Server",
+      "names": [
+        "start"
+      ],
+      "commands": [
+        "start-server"
+      ],
+      "kind": "other-command",
+      "why": "Launches an owned foreground daemon with -D, then sends new-session.",
+      "in": "lib/LibTmux/Server.rakumod",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Server.rakumod:141",
+          "has": [
+            "$!process = Proc::Async.new(:w, |$!endpoint.argv, '-D');"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:653",
+          "has": [
+            "$owner.launch;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Server.rakumod:665",
+          "has": [
+            "{ LEAVE $creator.close; created($creator, $observation, $command, :$cancel, :$deadline) }"
+          ]
+        }
+      ]
     }
   ]
 }
diff --git a/scripts/tmux-usage/preflights.json b/scripts/tmux-usage/preflights.json
index 7500cb449..30ded0559 100644
--- a/scripts/tmux-usage/preflights.json
+++ b/scripts/tmux-usage/preflights.json
@@ -38,6 +38,125 @@
           "within": "identityProbeArguments"
         }
       ]
+    },
+    {
+      "port": "raku",
+      "command": "run-shell",
+      "why": "Runtime.observe probes daemon identity with run-shell -C. Acquisition and capability checks share this observation path; explicit observation methods retain incidental claims, while the common identity probes are not credited to every facade.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Engine.rakumod:283",
+          "has": [
+            "my $first = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:285",
+          "has": [
+            "my $second = self!probe(:$cancel, :timeout-ms(self!remaining($until)));"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:247",
+          "has": [
+            "my $result = self!dispatch($command, :!check, :$cancel, :$timeout-ms);"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Engine.rakumod:245",
+          "has": [
+            "'run-shell', '-C', $marker ~ '#{version}/#{pid}/#{start_time}',"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "command": "display-message",
+      "why": "Control submissions append a display-message queue barrier to verify identity and completion. Explicit observe methods retain claims; this common barrier is not each submitted command’s purpose.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:365",
+          "has": [
+            "my $barrier = Invocation.new(:argv(['display-message', '-p',"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:369",
+          "has": [
+            "$wire ~= $barrier.source ~ \"\\n\";"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Control/Connection.rakumod:396",
+          "has": [
+            "else { $!queue.send($request) }"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "command": "list-clients",
+      "why": "Client-target operations revalidate the captured client name, PID and creation time before dispatch; this shared identity listing is separate from the requested UI operation.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:112",
+          "has": [
+            "my @clients = $runtime.read($projection, Invocation.new(:argv(['list-clients'])),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:118",
+          "has": [
+            "unless @matching.elems == 1;"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:131",
+          "has": [
+            "$runtime.execute($dispatch, :incarnation($!incarnation), :$cancel, :$deadline, :$check)"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "command": "list-panes",
+      "why": "Client UI operations with a pane argument verify membership in the observed client session before dispatch.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Client.rakumod:122",
+          "has": [
+            "'list-panes', '-s', '-t', @matching[0].value('session-id'),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Client.rakumod:126",
+          "has": [
+            "unless @rows.first(*.value('id') eq $pane).defined;"
+          ]
+        }
+      ]
+    },
+    {
+      "port": "raku",
+      "command": "list-windows",
+      "why": "WindowLinkRef operations validate the expected window at the retained session/index before the requested mutation.",
+      "evidence": [
+        {
+          "at": "lib/LibTmux/Model.rakumod:523",
+          "has": [
+            "Invocation.new(:argv(['list-windows', '-t', $!session-id])),"
+          ]
+        },
+        {
+          "at": "lib/LibTmux/Model.rakumod:526",
+          "has": [
+            "X::LibTmux::StaleReference.new(:message('Window link was removed or renumbered')).throw"
+          ]
+        }
+      ]
     }
   ]
 }
diff --git a/scripts/type-links-ceiling.json b/scripts/type-links-ceiling.json
index 6f5ccec31..92caa1326 100644
--- a/scripts/type-links-ceiling.json
+++ b/scripts/type-links-ceiling.json
@@ -20,5 +20,6 @@
   "perl": 1212,
   "lisp": 99,
   "ocaml": 2031,
-  "erlang": 0
+  "erlang": 0,
+  "raku": 923
 }
diff --git a/scripts/verify-destinations.negative.mjs b/scripts/verify-destinations.negative.mjs
index bfb4b74ee..3af1d9eaf 100644
--- a/scripts/verify-destinations.negative.mjs
+++ b/scripts/verify-destinations.negative.mjs
@@ -27,8 +27,8 @@
  * FAMILIES below. Every family gets the right package, a different package
  * under the same URL, and a version the manifest declares that the host lacks.
  * The families whose host reports a repository (PyPI, npm, crates.io,
- * RubyGems, the PowerShell Gallery, NuGet, LuaRocks, Maven Central, Hex and
- * javadoc.io) also get the right package filed under another repository and
+ * RubyGems, the PowerShell Gallery, NuGet, LuaRocks, Maven Central, Hex,
+ * MetaCPAN and javadoc.io) also get the right package filed under another repository and
  * one whose host reports no repository at all, and npm a directory that
  * differs. pkg.go.dev, docs.rs, HexDocs and the Swift Package Index name their
  * repository only in the URL, so they get none of those; pkg.go.dev instead
@@ -180,6 +180,14 @@ const FAMILIES = [
       routes[`/hex.pm/api/packages/${id}`] = () => text({ name: shown, latest_version: '1.0.0', releases: [{ version: '1.0.0' }], meta: { links: repo ? { GitHub: `https://github.com/${repo}` } : {} } })
     },
   },
+  {
+    host: 'raku-land', variants: REPORTS_REPOSITORY, coordinate: (id) => `${id}:auth<zef:demo>`, destination: (id) => ({ package: { host: 'raku-land', url: `https://raku.land/zef:demo/${id}` } }),
+    serve: (id, { shown, repo }) => {
+      const page = html(`Raku Land - ${shown}`, `<select id=version name=v><option value="1.0.0" disabled selected>1.0.0 (2026-01-01)</option></select>${repo ? `<a href="https://github.com/${repo}" rel=nofollow>github.com/${repo}</a>` : ''}`)
+      routes[`/raku.land/zef:demo/${id}`] = () => [200, 'text/html', page]
+      routes[`/raku.land/zef:demo/${id}?v=1.0.0`] = () => [200, 'text/html', page]
+    },
+  },
   {
     host: 'hexdocs', variants: NAMED_BY_URL, coordinate: (id) => id, destination: (id) => ({ api: { host: 'hexdocs', url: `https://${id}.hexdocs.pm/` } }),
     serve: (id, { shown }) => {
@@ -217,6 +225,21 @@ const FAMILIES = [
       routes[`/swiftpackageindex.com/demo/other/1.0.0/documentation/lib`] = () => [200, 'text/html', html('lib Documentation &ndash; Swift Package Index')]
     },
   },
+  {
+    // The distribution page is behind a challenge, so the API names it.
+    host: 'metacpan', variants: REPORTS_REPOSITORY, coordinate: (id) => id, destination: (id) => ({ package: { host: 'metacpan', url: `https://metacpan.org/dist/${id}` } }),
+    serve: (id, { shown, repo }) => cpanRelease(id, shown, repo),
+  },
+  {
+    // A module's POD page is read from its rendered NAME section; the module endpoint says which file documents it.
+    host: 'metacpan-pod', variants: REPORTS_REPOSITORY, coordinate: (id) => id, destination: (id) => ({ api: { host: 'metacpan', url: `https://metacpan.org/pod/${podModule(id)}` } }),
+    serve: (id, { shown, repo }) => {
+      const module = podModule(id)
+      cpanRelease(`${id}-dist`, `${id}-dist`, repo)
+      routes[`/fastapi.metacpan.org/v1/module/${module}`] = () => text({ documentation: shown === id ? module : shown, distribution: `${id}-dist`, version: '1.0.0', path: 'lib/Demo.pm' })
+      routes[`/fastapi.metacpan.org/v1/pod/${module}`] = () => [200, 'text/html', `<h1 id="NAME">NAME</h1>\n<p>${module} - a demo</p>`]
+    },
+  },
 ]
 
 /** A Go module on the proxy: the versions it lists, and where in its repository the proxy says it lives. */
@@ -225,6 +248,15 @@ function goModule(path, versions, subdir) {
   for (const version of versions) routes[`/proxy.golang.org/${path}/@v/${version}.info`] = () => text({ Version: version, Origin: { VCS: 'git', ...(subdir && { Subdir: subdir }) } })
 }
 
+/** A Perl module name for a case id, since a POD NAME section names `Word::Word`. */
+const podModule = (id) => `Demo::${id.replace(/(?:^|[^A-Za-z0-9]+)(\w)/g, (_, letter) => letter.toUpperCase())}`
+
+/** A CPAN distribution as the MetaCPAN API lists it: its newest release, filed under `repo`, and every release it carries. */
+function cpanRelease(dist, shown, repo, versions = ['1.0.0']) {
+  routes[`/fastapi.metacpan.org/v1/release/${dist}`] = () => text({ distribution: shown, version: versions.at(-1), status: 'latest', resources: repo ? { repository: { url: `git://github.com/${repo}.git`, web: `https://github.com/${repo}` } } : {} })
+  routes[`/fastapi.metacpan.org/v1/release/_search?q=distribution:${dist}&size=100`] = () => text({ hits: { hits: versions.map((version) => ({ _source: { distribution: dist, version, status: 'cpan', maturity: 'released' } })) } })
+}
+
 /** Any other repository under demo/ is a page titled for itself, and a directory of one is titled as GitHub titles it. */
 function github(path) {
   const tree = /^\/github\.com\/demo\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)$/.exec(path)
@@ -242,8 +274,8 @@ const server = createServer((request, response) => {
 })
 await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
 const base = `http://127.0.0.1:${server.address().port}`
-const ORIGINS = ['github.com', 'pypi.org', 'rubygems.org', 'javadoc.io', 'registry.npmjs.org', 'www.npmjs.com', 'crates.io', 'repo1.maven.org', 'central.sonatype.com',
-  'www.nuget.org', 'api.nuget.org', 'www.powershellgallery.com', 'luarocks.org', 'pkg.go.dev', 'proxy.golang.org', 'docs.rs', 'swiftpackageindex.com', 'hex.pm',
+const ORIGINS = ['fastapi.metacpan.org', 'github.com', 'pypi.org', 'rubygems.org', 'javadoc.io', 'registry.npmjs.org', 'www.npmjs.com', 'crates.io', 'repo1.maven.org', 'central.sonatype.com',
+  'www.nuget.org', 'api.nuget.org', 'www.powershellgallery.com', 'luarocks.org', 'pkg.go.dev', 'proxy.golang.org', 'docs.rs', 'swiftpackageindex.com', 'hex.pm', 'raku.land',
   // HexDocs gives each package a host of its own, so each package a case serves is an origin.
   ...NAMED_BY_URL.map((variant) => `hexdocs-${variant}.hexdocs.pm`)]
 const rewrite = JSON.stringify(Object.fromEntries(ORIGINS.map((host) => [`https://${host}`, `${base}/${host}`])))
@@ -474,6 +506,41 @@ const recordFor = (url) => good.destinations.find((candidate) => candidate.url =
 const source = recordFor('https://github.com/demo/demo')
 const withPypi = (change) => ({ ...good, destinations: good.destinations.map((item) => (item.host === 'pypi' ? { ...item, ...change } : item)) })
 const check1 = (version, check, extra = {}) => [{ version, source: 'demo/demo:m', ports: ['demo'], check, ...extra }]
+
+// MetaCPAN: PAUSE indexes no developer release, so a manifest at a development commit that declares one is not a claim of a release.
+// The same version on a host that does list such releases is still one the host lacks.
+cpanRelease('demo-cpan', 'demo-cpan', 'demo/demo', ['0.002', '0.003'])
+const cpanDist = { package: { host: 'metacpan', url: 'https://metacpan.org/dist/demo-cpan' } }
+const developer = await verify('a developer version on MetaCPAN is recorded as one and passes', [entry('demo-cpan', { coordinate: 'demo-cpan', ...cpanDist })], {
+  manifests: manifestFor([['demo-cpan', '0.001_001']]), expect: { code: 0, matches: [/ok\s+200\s+package\s+https:\/\/metacpan\.org\/dist\/demo-cpan/], excludes: [/problem/] },
+})
+const developerChecks = JSON.parse(readFileSync(developer.out, 'utf8')).destinations.find((candidate) => candidate.url === 'https://metacpan.org/dist/demo-cpan')?.versionChecks
+if (developerChecks?.length === 1 && developerChecks[0].check === 'developer' && developerChecks[0].version === '0.001_001') console.log('ok   the record says the version is a developer version and checked nothing against the host')
+else { console.error(`FAIL the record did not name a developer version: ${JSON.stringify(developerChecks)}`); failures += 1 }
+await verify('a released version MetaCPAN carries is confirmed', [entry('demo-cpan', { coordinate: 'demo-cpan', ...cpanDist })], {
+  manifests: manifestFor([['demo-cpan', '0.003']]), expect: { code: 0, matches: [/ok\s+200\s+package\s+https:\/\/metacpan\.org\/dist\/demo-cpan/], excludes: [/problem/] },
+})
+await verify('a developer version on a host that lists them is a version the host lacks', control, {
+  manifests: manifestFor([['demo-good', '0.001_001']]), expect: { code: 1, matches: [/does not carry 0\.001_001/] },
+})
+await verify('offline, a developer version recorded for a release number fails', [entry('demo-cpan', { coordinate: 'demo-cpan', ...cpanDist })], {
+  args: ['--check'], manifests: manifestFor([['demo-cpan', '0.003']]),
+  evidence: { schema: 1, checkedAt: '2026-01-01', destinations: [
+    { ...JSON.parse(readFileSync(developer.out, 'utf8')).destinations.find((candidate) => candidate.url === 'https://metacpan.org/dist/demo-cpan'), versionChecks: check1('0.003', 'developer') },
+    source,
+  ] },
+  expect: { code: 1, matches: [/records 0\.003 as a developer version, which metacpan does not issue/] },
+})
+// MetaCPAN answers a scripted client's page request with a challenge; the POD page is read from its NAME section.
+routes['/fastapi.metacpan.org/v1/module/Demo::Challenged'] = () => text({ documentation: 'Demo::Challenged', distribution: 'demo-cpan', version: '0.003', path: 'lib/Demo/Challenged.pm' })
+routes['/fastapi.metacpan.org/v1/pod/Demo::Challenged'] = () => [200, 'text/html', html('Client Challenge', '<h1>Client Challenge</h1>')]
+routes['/fastapi.metacpan.org/v1/module/Demo::Other'] = () => text({ documentation: 'Demo::Other', distribution: 'demo-cpan', version: '0.003', path: 'lib/Demo/Other.pm' })
+routes['/fastapi.metacpan.org/v1/pod/Demo::Other'] = () => [200, 'text/html', '<h1 id="NAME">NAME</h1><p>Demo::Elsewhere - declares another module</p>']
+routes['/fastapi.metacpan.org/v1/module/Demo::Shared::Error'] = () => text({ documentation: 'Demo::Shared', distribution: 'demo-cpan', version: '0.003', path: 'lib/Demo/Shared.pm' })
+for (const [module, matches] of [['Demo::Challenged', /FAIL\s+200\s+api[\s\S]*the POD names "" in its NAME section/], ['Demo::Other', /FAIL\s+200\s+api[\s\S]*the POD names "Demo::Elsewhere" in its NAME section/],
+  ['Demo::Shared::Error', /FAIL\s+200\s+api[\s\S]*MetaCPAN documents "Demo::Shared" in lib\/Demo\/Shared\.pm, expected "Demo::Shared::Error"/]]) {
+  await verify(`MetaCPAN POD for ${module} is refused`, [entry('demo-pod', { api: { host: 'metacpan', url: `https://metacpan.org/pod/${module}` } })], { expect: { code: 1, matches: [matches] } })
+}
 await verify('offline, evidence for every destination passes', control, { args: ['--check'], evidence: good, expect: { code: 0, matches: [/agrees with the inventory/] } })
 await verify('offline, a destination with no record fails', control, {
   args: ['--check'], evidence: { ...good, destinations: [source] }, expect: { code: 1, matches: [/https:\/\/pypi\.org\/project\/demo-good\/ has no evidence/] },
diff --git a/scripts/xref-floor.json b/scripts/xref-floor.json
index f89b51a4c..f8240cdc9 100644
--- a/scripts/xref-floor.json
+++ b/scripts/xref-floor.json
@@ -20,5 +20,6 @@
   "fsharp": 284,
   "lisp": 1272,
   "ocaml": 4584,
-  "erlang": 2919
+  "erlang": 2919,
+  "raku": 3494
 }
diff --git a/site/public/_shell/brand.css b/site/public/_shell/brand.css
index 6b3612828..1313e3942 100644
--- a/site/public/_shell/brand.css
+++ b/site/public/_shell/brand.css
@@ -2749,3 +2749,128 @@ html[data-brand="lisp"][data-theme-mode="dark"], html[data-brand="lisp"][data-th
   --lt-color-code-bg: #1c2229;
   }
 }
+html[data-brand="raku"] {
+  color-scheme: light;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #0000b0;
+  --theme-secondary: #53606d;
+  --theme-accent: #0000b0;
+  --theme-background: #fafbfc;
+  --theme-text: #202830;
+  --background-color: #fafbfc;
+  --text-color: #202830;
+  --topnav-background: #fafbfc;
+  --topnav-text-color: #202830;
+  --topnav-link-color: #53606d;
+  --topnav-link-hover-color: #202830;
+  --color-background-primary: #fafbfc;
+  --color-background-secondary: #f3f5f7;
+  --color-background-border: #d6dce3;
+  --color-api-background-hover: #e9edf1;
+  --color-foreground-primary: #202830;
+  --color-foreground-secondary: #53606d;
+  --color-foreground-muted: #53606d;
+  --color-link: #0000b0;
+  --color-brand-primary: #0000b0;
+  --color-brand-content: #0000b0;
+  --color-inline-code-background: #f3f5f7;
+  --lt-color-bg: #fafbfc;
+  --lt-color-bg-secondary: #f3f5f7;
+  --lt-color-bg-hover: #e9edf1;
+  --lt-color-fg: #202830;
+  --lt-color-fg-secondary: #53606d;
+  --lt-color-fg-muted: #53606d;
+  --lt-color-border: #d6dce3;
+  --lt-color-accent: #0000b0;
+  --lt-color-link: #0000b0;
+  --lt-color-link-visited: #0000b0;
+  --lt-color-code-bg: #f3f5f7;
+}
+html[data-brand="raku"][data-theme-mode="dark"], html[data-brand="raku"][data-theme="dark"] {
+  color-scheme: dark;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #8c8cfd;
+  --theme-secondary: #b7c1cd;
+  --theme-accent: #8c8cfd;
+  --theme-background: #15191d;
+  --theme-text: #e7edf3;
+  --background-color: #15191d;
+  --text-color: #e7edf3;
+  --topnav-background: #15191d;
+  --topnav-text-color: #e7edf3;
+  --topnav-link-color: #b7c1cd;
+  --topnav-link-hover-color: #e7edf3;
+  --color-background-primary: #15191d;
+  --color-background-secondary: #1c2229;
+  --color-background-border: #3e4a57;
+  --color-api-background-hover: #29323d;
+  --color-foreground-primary: #e7edf3;
+  --color-foreground-secondary: #b7c1cd;
+  --color-foreground-muted: #b7c1cd;
+  --color-link: #8c8cfd;
+  --color-brand-primary: #8c8cfd;
+  --color-brand-content: #8c8cfd;
+  --color-inline-code-background: #1c2229;
+  --lt-color-bg: #15191d;
+  --lt-color-bg-secondary: #1c2229;
+  --lt-color-bg-hover: #29323d;
+  --lt-color-fg: #e7edf3;
+  --lt-color-fg-secondary: #b7c1cd;
+  --lt-color-fg-muted: #b7c1cd;
+  --lt-color-border: #3e4a57;
+  --lt-color-accent: #8c8cfd;
+  --lt-color-link: #8c8cfd;
+  --lt-color-link-visited: #8c8cfd;
+  --lt-color-code-bg: #1c2229;
+}
+@media (prefers-color-scheme: dark) {
+  html[data-brand="raku"]:not([data-theme-mode]):not([data-theme="light"]) {
+  color-scheme: dark;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #8c8cfd;
+  --theme-secondary: #b7c1cd;
+  --theme-accent: #8c8cfd;
+  --theme-background: #15191d;
+  --theme-text: #e7edf3;
+  --background-color: #15191d;
+  --text-color: #e7edf3;
+  --topnav-background: #15191d;
+  --topnav-text-color: #e7edf3;
+  --topnav-link-color: #b7c1cd;
+  --topnav-link-hover-color: #e7edf3;
+  --color-background-primary: #15191d;
+  --color-background-secondary: #1c2229;
+  --color-background-border: #3e4a57;
+  --color-api-background-hover: #29323d;
+  --color-foreground-primary: #e7edf3;
+  --color-foreground-secondary: #b7c1cd;
+  --color-foreground-muted: #b7c1cd;
+  --color-link: #8c8cfd;
+  --color-brand-primary: #8c8cfd;
+  --color-brand-content: #8c8cfd;
+  --color-inline-code-background: #1c2229;
+  --lt-color-bg: #15191d;
+  --lt-color-bg-secondary: #1c2229;
+  --lt-color-bg-hover: #29323d;
+  --lt-color-fg: #e7edf3;
+  --lt-color-fg-secondary: #b7c1cd;
+  --lt-color-fg-muted: #b7c1cd;
+  --lt-color-border: #3e4a57;
+  --lt-color-accent: #8c8cfd;
+  --lt-color-link: #8c8cfd;
+  --lt-color-link-visited: #8c8cfd;
+  --lt-color-code-bg: #1c2229;
+  }
+}
diff --git a/site/public/_shell/shell.js b/site/public/_shell/shell.js
index b0893c973..ad87b2abc 100644
--- a/site/public/_shell/shell.js
+++ b/site/public/_shell/shell.js
@@ -26,6 +26,7 @@
     {"slug":"swift","name":"Swift","shortName":"Sw","logoLanguage":"swift","versionedDocs":true,"mcp":true},
     {"slug":"ocaml","name":"OCaml","shortName":"ML","logoLanguage":"ocaml","versionedDocs":true,"mcp":false},
     {"slug":"perl","name":"Perl","shortName":"Pl","logoLanguage":"perl","versionedDocs":true,"mcp":false},
+    {"slug":"raku","name":"Raku","shortName":"Raku","logoLanguage":"raku","versionedDocs":true,"mcp":false},
   ]
   // <<< end generated
 
diff --git a/site/public/brand/catalog.json b/site/public/brand/catalog.json
index 68a5ac2a2..3ab9c947d 100644
--- a/site/public/brand/catalog.json
+++ b/site/public/brand/catalog.json
@@ -29696,7 +29696,438 @@
           "format": "xml"
         }
       ]
+    },
+    {
+      "language": "raku",
+      "label": "Raku",
+      "variant": "library",
+      "githubColor": "#0000fb",
+      "alt": "libtmux for Raku",
+      "files": [
+        {
+          "file": "raku/library/logo.svg",
+          "bytes": 5879,
+          "sha256": "d29de9b0d137e07e41e919a1b4e339b3b4f25830320dd47bb503ac6507cd14cb",
+          "format": "svg",
+          "width": 512,
+          "height": 512,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-16.png",
+          "bytes": 563,
+          "sha256": "66dff74ed31f19515d4fe93f7e2a37647c600cf92ecea3902fc3a4a3c4b68545",
+          "format": "png",
+          "width": 16,
+          "height": 16,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-24.png",
+          "bytes": 751,
+          "sha256": "4a7ac0dd1d229e62d9d92930e331db00a762527103b3840a34e638f5e4d0ea79",
+          "format": "png",
+          "width": 24,
+          "height": 24,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-32.png",
+          "bytes": 1009,
+          "sha256": "6ff0537aa942c284f50ece1fae4a244d368280522c0447a86082b55319657807",
+          "format": "png",
+          "width": 32,
+          "height": 32,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-48.png",
+          "bytes": 1458,
+          "sha256": "162feed5b2a715fd7cf830e72d141f972465b48a62ca942d7310739f09335228",
+          "format": "png",
+          "width": 48,
+          "height": 48,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-64.png",
+          "bytes": 1887,
+          "sha256": "23408529a0e37c98f695ffdc1fd407caff307ba1f554bdfeca57ce765392b0f7",
+          "format": "png",
+          "width": 64,
+          "height": 64,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-96.png",
+          "bytes": 2725,
+          "sha256": "6688886c3505b05eb8d0591a058a4ece1920da6a80ddbc84a4a3fa60e026d67b",
+          "format": "png",
+          "width": 96,
+          "height": 96,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-128.png",
+          "bytes": 3644,
+          "sha256": "0fedf8ae7574d25038463e5eb77a1f9587d4ea4fbe36839c68f4074de7b2ed1b",
+          "format": "png",
+          "width": 128,
+          "height": 128,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-144.png",
+          "bytes": 4092,
+          "sha256": "0c8533c0bdac2f4cfedd4741e3a34b51d9116481dc4e640058cff41f6df704ed",
+          "format": "png",
+          "width": 144,
+          "height": 144,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-152.png",
+          "bytes": 4241,
+          "sha256": "2b97c3cc942a8a34db6268164b264f02f5b7030b5870a0a612b24d6b46608a73",
+          "format": "png",
+          "width": 152,
+          "height": 152,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-167.png",
+          "bytes": 4680,
+          "sha256": "8e23cf4bab3145d61abee4da34c26caa6711d9b2993f8b81a39677b52bcb5b4f",
+          "format": "png",
+          "width": 167,
+          "height": 167,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-180.png",
+          "bytes": 5176,
+          "sha256": "41478eed635a47867e9c5e2fd81ad518f56e1aca7dfce45e62b72e1fdba74312",
+          "format": "png",
+          "width": 180,
+          "height": 180,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-192.png",
+          "bytes": 5499,
+          "sha256": "9faaf59f1c1b708418480c346ebd80bbe22425addf1db455b493f1fa0df88196",
+          "format": "png",
+          "width": 192,
+          "height": 192,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-256.png",
+          "bytes": 7440,
+          "sha256": "fde027226f1f7b33dc07f64a5fb660cb5e220dd76e948b4518fc7278874cf3da",
+          "format": "png",
+          "width": 256,
+          "height": 256,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-384.png",
+          "bytes": 11534,
+          "sha256": "03a10bcb4c5e508b407eedcf9136d1d46cde4e7daf86f8243245bad596ce451e",
+          "format": "png",
+          "width": 384,
+          "height": 384,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-512.png",
+          "bytes": 15988,
+          "sha256": "4cb45d5d6f0a33c479795a32a58d3e44a7dd2d2e0c1bbfd1baa975d5e1c50483",
+          "format": "png",
+          "width": 512,
+          "height": 512,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/logo-1024.png",
+          "bytes": 36310,
+          "sha256": "905f7c9f105d85a332b120598b8f59eafe0d2c5da725909a7e1167043f3b1b04",
+          "format": "png",
+          "width": 1024,
+          "height": 1024,
+          "transparent": true
+        },
+        {
+          "file": "raku/library/favicon.ico",
+          "bytes": 22542,
+          "sha256": "d32346301b8c95f4074c42382eab7d518758b10035225723acbda69ee1022f05",
+          "format": "ico",
+          "sizes": [
+            16,
+            32,
+            48,
+            256
+          ]
+        },
+        {
+          "file": "raku/library/safari-pinned-tab.svg",
+          "bytes": 5879,
+          "sha256": "290b7e5f70062386563d6bf4f5768ed6605a618cd3b608354ca600d68616284f",
+          "format": "svg",
+          "width": 512,
+          "height": 512,
+          "monochrome": true
+        },
+        {
+          "file": "raku/library/apple-touch-icon-light.png",
+          "bytes": 3857,
+          "sha256": "031004f812ad5dad209c82d881fdd8853d3784064425e88726c531cc1881270d",
+          "format": "png",
+          "width": 180,
+          "height": 180,
+          "transparent": false,
+          "purpose": "apple-touch"
+        },
+        {
+          "file": "raku/library/app-icon-1024-light.png",
+          "bytes": 28394,
+          "sha256": "86a140bd45afd5c4450bae7f864d60cfd0a25b1d7d3f76a8dd32f110c77546be",
+          "format": "png",
+          "width": 1024,
+          "height": 1024,
+          "transparent": false,
+          "purpose": "app-icon"
+        },
+        {
+          "file": "raku/library/maskable-192-light.png",
+          "bytes": 3084,
+          "sha256": "2588e7514f9531b86ee2a1826f0833d95c79290c54293ebf6f580303d9b220ea",
+          "format": "png",
+          "width": 192,
+          "height": 192,
+          "transparent": false,
+          "purpose": "maskable",
+          "contentFraction": 0.52
+        },
+        {
+          "file": "raku/library/maskable-512-light.png",
+          "bytes": 9293,
+          "sha256": "9cf9371c9ff12256ea235f4b59508294dc0e60488d04634118536879d1f97faa",
+          "format": "png",
+          "width": 512,
+          "height": 512,
+          "transparent": false,
+          "purpose": "maskable",
+          "contentFraction": 0.52
+        },
+        {
+          "file": "raku/library/mstile-150-light.png",
+          "bytes": 2999,
+          "sha256": "dcd60dcd8e347e4bae3a649d4104c9caf11f39f2f6b1b06e800ad2eeb77ea43e",
+          "format": "png",
+          "width": 150,
+          "height": 150,
+          "transparent": false,
+          "purpose": "windows-tile"
+        },
+        {
+          "file": "raku/library/mstile-310-light.png",
+          "bytes": 6525,
+          "sha256": "18ef095ad71e0d2f320a209d7b1b9d59ed6bf7576b4333b9f0cc2b543c2981d3",
+          "format": "png",
+          "width": 310,
+          "height": 310,
+          "transparent": false,
+          "purpose": "windows-tile"
+        },
+        {
+          "file": "raku/library/opengraph-light.png",
+          "bytes": 25134,
+          "sha256": "9ac90c0cbc233162bc71d1de93466736171dc6aac90090466100dc8b54a8fc39",
+          "format": "png",
+          "width": 1200,
+          "height": 630,
+          "transparent": false,
+          "purpose": "opengraph"
+        },
+        {
+          "file": "raku/library/opengraph-light.jpg",
+          "bytes": 46117,
+          "sha256": "e27ee0a46b91971d8dd95150b7ecffde754b1aa47c40d7e884aabdc64688ffba",
+          "format": "jpeg",
+          "width": 1200,
+          "height": 630,
+          "transparent": false,
+          "purpose": "opengraph-fallback"
+        },
+        {
+          "file": "raku/library/twitter-light.png",
+          "bytes": 24965,
+          "sha256": "760d706412948ca09da22cfcdd41884ca6d5b5538cbf1bb391733f6e8e23d7f9",
+          "format": "png",
+          "width": 1200,
+          "height": 600,
+          "transparent": false,
+          "purpose": "twitter"
+        },
+        {
+          "file": "raku/library/social-square-light.png",
+          "bytes": 28890,
+          "sha256": "0e2c83ef136c6f516629e858357db97e3f375b77551dad9eebaab90c0fb9ec71",
+          "format": "png",
+          "width": 1080,
+          "height": 1080,
+          "transparent": false,
+          "purpose": "social-square"
+        },
+        {
+          "file": "raku/library/github-social-light.png",
+          "bytes": 25516,
+          "sha256": "c348d034527fddae0735ce160632af604bb0c24298a1152067c9125f707b7328",
+          "format": "png",
+          "width": 1280,
+          "height": 640,
+          "transparent": false,
+          "purpose": "github-social"
+        },
+        {
+          "file": "raku/library/site.webmanifest",
+          "bytes": 729,
+          "sha256": "791f24cba4c1427afcfd03b660d43f2a2e33b85c2e7522c0a9b627393f9658f4",
+          "format": "webmanifest"
+        },
+        {
+          "file": "raku/library/browserconfig.xml",
+          "bytes": 238,
+          "sha256": "a275b5bf7cf9484884c1fd85f2aaeead64e4eef44785c7390f715bc81c4dbd87",
+          "format": "xml"
+        },
+        {
+          "file": "raku/library/apple-touch-icon-dark.png",
+          "bytes": 3873,
+          "sha256": "abb814cf8cd8d691d028d6848fb1c6f62b873511c19febdb22b53086c2fe02f6",
+          "format": "png",
+          "width": 180,
+          "height": 180,
+          "transparent": false,
+          "purpose": "apple-touch"
+        },
+        {
+          "file": "raku/library/app-icon-1024-dark.png",
+          "bytes": 28683,
+          "sha256": "5873a255a31c9e94e7fb9077016deecb39c3fe3cbff811eb9e0ef0d4d6d668c8",
+          "format": "png",
+          "width": 1024,
+          "height": 1024,
+          "transparent": false,
+          "purpose": "app-icon"
+        },
+        {
+          "file": "raku/library/maskable-192-dark.png",
+          "bytes": 3114,
+          "sha256": "02cf7a6a92a5f2f1682b2f3fa1547cd2397003ed17ff27cfdb69f093edc28a81",
+          "format": "png",
+          "width": 192,
+          "height": 192,
+          "transparent": false,
+          "purpose": "maskable",
+          "contentFraction": 0.52
+        },
+        {
+          "file": "raku/library/maskable-512-dark.png",
+          "bytes": 9375,
+          "sha256": "42bcd9ff5f1c960c1bb9019eb9d235cb5e49db703fc4361c04d6d22c59037834",
+          "format": "png",
+          "width": 512,
+          "height": 512,
+          "transparent": false,
+          "purpose": "maskable",
+          "contentFraction": 0.52
+        },
+        {
+          "file": "raku/library/mstile-150-dark.png",
+          "bytes": 3024,
+          "sha256": "f4b4fabf34865a50077a5e96ded570e095eb66033d0b7e259636f36ac442bf2e",
+          "format": "png",
+          "width": 150,
+          "height": 150,
+          "transparent": false,
+          "purpose": "windows-tile"
+        },
+        {
+          "file": "raku/library/mstile-310-dark.png",
+          "bytes": 6578,
+          "sha256": "01be9b8ce61c01349e8f490ebd4c41a95c745d43471358f563b006d89d14d198",
+          "format": "png",
+          "width": 310,
+          "height": 310,
+          "transparent": false,
+          "purpose": "windows-tile"
+        },
+        {
+          "file": "raku/library/opengraph-dark.png",
+          "bytes": 25396,
+          "sha256": "660ef6b57a1c45657fad9229d45b132c35d95346063278e1fd4969e8ff5f0a3b",
+          "format": "png",
+          "width": 1200,
+          "height": 630,
+          "transparent": false,
+          "purpose": "opengraph"
+        },
+        {
+          "file": "raku/library/opengraph-dark.jpg",
+          "bytes": 43791,
+          "sha256": "cc6971140c97e02ce7f334bc231e1124bc5afa8151023a7260cb76e161a25ff3",
+          "format": "jpeg",
+          "width": 1200,
+          "height": 630,
+          "transparent": false,
+          "purpose": "opengraph-fallback"
+        },
+        {
+          "file": "raku/library/twitter-dark.png",
+          "bytes": 25219,
+          "sha256": "85b09f4c814224590c2c8bb02037cf3e2ba90b10d46ac972aaac751770bb5b50",
+          "format": "png",
+          "width": 1200,
+          "height": 600,
+          "transparent": false,
+          "purpose": "twitter"
+        },
+        {
+          "file": "raku/library/social-square-dark.png",
+          "bytes": 29151,
+          "sha256": "a9fca634a2ef64b844c7627dddfe9ad790804201ee96dbec54e156a30d9be93c",
+          "format": "png",
+          "width": 1080,
+          "height": 1080,
+          "transparent": false,
+          "purpose": "social-square"
+        },
+        {
+          "file": "raku/library/github-social-dark.png",
+          "bytes": 25777,
+          "sha256": "2af6f52eeddd561bce31d795ec2e5fb2444e214360ab3830bd0b1cac981dc1fc",
+          "format": "png",
+          "width": 1280,
+          "height": 640,
+          "transparent": false,
+          "purpose": "github-social"
+        },
+        {
+          "file": "raku/library/site-dark.webmanifest",
+          "bytes": 727,
+          "sha256": "de8d65e1efc4d546603180e228c3e263c7ef3163f4c4b56893791bf3c93566cb",
+          "format": "webmanifest"
+        },
+        {
+          "file": "raku/library/browserconfig-dark.xml",
+          "bytes": 236,
+          "sha256": "1fa4e33a8b34b8f169bcc71d3246f5c398412645aa19fb05c638a43b75ae13bf",
+          "format": "xml"
+        }
+      ]
     }
   ],
-  "fileCount": 3100
+  "fileCount": 3145
 }
diff --git a/site/public/brand/languages/raku/icon.svg b/site/public/brand/languages/raku/icon.svg
new file mode 100644
index 000000000..4ac2b0612
--- /dev/null
+++ b/site/public/brand/languages/raku/icon.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 135.46667 135.46666" role="img" aria-label="libtmux for Raku" class="libtmux-logo" data-language="raku" data-variant="library" focusable="false"><title>libtmux for Raku</title><g transform="translate(-210.28959,-409.98108)" data-part="artwork"><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="primary-tile"><path d="M 227.78906,0 213.98242,3.6992188 V 460.62109 H 241.4082 V 15.564453 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#0000B0" data-part="primary-edge"></path><path d="m 210.28981,417.13553 v 113.86425 l 60.26885,2.60089 V 409.98109 h -53.11441 c -3.95129,0 -7.15444,3.20315 -7.15444,7.15444 z" fill="#0000fb" data-part="primary"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="lower-tile"><path d="m 486.38086,246.03906 -5.24805,4.99805 v 207.2207 l 5.24805,-0.93164 L 500,465.18945 V 261.60352 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#000071" data-part="lower-edge"></path><path d="m 278.70874,475.07917 v 64.8875 l 60.26883,-8.98455 v -55.90295 z" fill="#0000A3" data-part="lower"></path></g><path d="m 210.28959,533.88585 v 4.23589 c 9e-5,4.04619 3.2803,7.32617 7.32649,7.32598 h 28.63105 l 81.26967,-1.0223 14.5495,-10.53906 v 0 z" fill="#231F20" data-part="base"></path><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="upper-tile"><path d="m 459.33984,0 -25.33593,2.1074219 h 21.38281 c 14.93397,0 27.04101,12.1070061 27.04101,27.0410161 V 129.83008 l 6.17579,13.24609 L 500,112.43359 V 42.603516 C 499.99913,8.8176763 474.27408,-6.8031496e-4 459.33984,0 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#4040FC" data-part="upper-side"></path><path d="m 331.82331,409.98109 h -53.11442 v 56.93261 h 60.26885 v -49.77817 c 0,-3.95129 -3.20315,-7.15444 -7.15443,-7.15444 z" fill="#8C8CFD" data-part="upper"></path><path d="m 278.7089,466.9137 h 60.26885 l 3.6035,4.11782 h -60.26932 z" fill="#0000E2" data-part="upper-bottom"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="gear-group"><path d="m 298.35661,419.37889 c -3.307,0 -6.01087,2.63649 -6.0946,5.94228 l -0.33026,13.04677 c -0.0503,1.98883 -1.3048,3.74588 -3.16843,4.44175 -1.63527,0.6105 -3.23561,1.29298 -4.79768,2.04293 -1.82786,0.87796 -4.00547,0.54134 -5.47527,-0.85609 l -9.17457,-8.72115 c -2.39692,-2.27863 -6.17361,-2.23122 -8.512,0.10759 l -14.3945,14.39447 c -1.27625,1.27604 -1.86544,2.98029 -1.77147,4.65491 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22023 -0.0123,0.44029 0,0.66053 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0838,1.61437 0.46467,3.25669 1.6634,4.51768 l 8.99461,9.46208 c 0.23074,0.24278 0.42181,0.51038 0.59418,0.78721 -0.60023,1.35769 -1.15279,2.74067 -1.64984,4.15071 -0.6727,1.90958 -2.45019,3.20822 -4.47443,3.25942 l -12.65165,0.31971 c -3.30618,0.0837 -5.94279,2.7886 -5.94279,6.0956 v 0.66053 0.66053 0.66053 0.66056 2.64112 15.07361 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 c 0,3.30703 2.63661,6.01136 5.94279,6.09511 l 13.04677,0.32975 c 1.98885,0.0503 3.74539,1.30529 4.44124,3.16895 0.53531,1.43379 1.12957,2.83886 1.7725,4.21655 -0.17026,0.27145 -0.35881,0.53398 -0.58564,0.77264 l -8.72163,9.17405 c -1.19922,1.26148 -1.74723,2.90475 -1.66291,4.51969 -0.0124,0.22024 -0.0118,0.44029 0,0.66053 v 0.0457 h 0.0875 l 10.03868,-9.51839 29.63949,8.95286 h 43.47603 l 13.935,-16.69426 v -0.0216 c -8.04912,9.72841 -20.24315,15.90068 -33.88319,15.7844 -22.83086,-0.19494 -41.62302,-18.24181 -43.0251,-40.7806 1.34121,-22.94291 20.4588,-41.11551 43.78415,-40.91631 13.2902,0.11325 25.20451,6.28323 33.12414,15.86034 v -3.90741 -20.27843 -11.02398 l -3.97024,3.7742 c -1.44419,1.37264 -3.57681,1.72648 -5.38882,0.89729 -1.57465,-0.72024 -3.18724,-1.3729 -4.83384,-1.95295 -1.90955,-0.67268 -3.2077,-2.45012 -3.25892,-4.47392 l -0.32023,-12.65265 c -0.0836,-3.30579 -2.78757,-5.94228 -6.09457,-5.94228 z" fill="#999999" data-part="gear-edge"></path><path d="m 298.35715,419.3789 c -3.30703,0 -6.01139,2.63697 -6.09511,5.94277 l -0.33075,13.04677 c -0.0504,1.98885 -1.30431,3.74539 -3.16795,4.44126 -1.63521,0.6105 -3.23553,1.29298 -4.79716,2.04293 -1.8283,0.87755 -4.0065,0.54134 -5.47627,-0.85609 l -9.17408,-8.72115 c -2.39692,-2.27863 -6.17372,-2.23122 -8.51252,0.10759 l -14.39447,14.39498 c -2.33842,2.33839 -2.38624,6.1146 -0.10759,8.51152 l 8.9951,9.46211 c 1.37305,1.44416 1.72558,3.57678 0.89681,5.38881 -0.72068,1.57466 -1.37293,3.18676 -1.95295,4.83335 -0.67271,1.90958 -2.45022,3.20823 -4.47444,3.25942 l -12.65164,0.32023 c -3.30621,0.0837 -5.9428,2.78759 -5.9428,6.09459 v 20.35786 c 0,3.30703 2.63659,6.01087 5.9428,6.09459 l 13.04677,0.33027 c 1.98843,0.0504 3.74578,1.30479 4.44123,3.16846 0.61094,1.63521 1.29301,3.2356 2.04295,4.79765 0.87797,1.82789 0.54145,4.00591 -0.85559,5.47527 l -8.72164,9.17457 c -1.37514,1.44653 -1.88755,3.39384 -1.57592,5.22595 h 0.7465 24.32055 61.26465 3.60327 c 3.95126,0 7.15424,-3.20297 7.15424,-7.15427 v -2.056 -8.04952 c -8.05257,9.71866 -20.25002,15.87899 -33.88271,15.76278 -23.61284,-0.2016 -42.90943,-19.4986 -43.11104,-43.11106 -0.20729,-24.31847 19.55063,-44.07731 43.86912,-43.8696 13.28515,0.11319 25.2041,6.27146 33.12463,15.84172 v -18.88347 -11.02398 l -3.97073,3.77469 c -1.44417,1.37264 -3.57578,1.72599 -5.38782,0.8968 -1.57506,-0.72024 -3.18776,-1.37292 -4.83435,-1.95295 -1.90958,-0.67309 -3.20729,-2.45063 -3.25892,-4.47441 l -0.32023,-12.65167 c -0.0833,-3.3058 -2.78767,-5.94277 -6.09509,-5.94277 z" fill="#E6E6E6" data-part="gear"></path></g></g></svg>
diff --git a/site/public/brand/languages/raku/provenance.json b/site/public/brand/languages/raku/provenance.json
new file mode 100644
index 000000000..348652d10
--- /dev/null
+++ b/site/public/brand/languages/raku/provenance.json
@@ -0,0 +1,19 @@
+{
+  "name": "Raku",
+  "asset": "icon.svg",
+  "sourceUrl": "https://raw.githubusercontent.com/libtmux/assets/55dd6eac4347ba22270788b74a71ec0cba12e287/assets/raku/library/logo.svg",
+  "resolvedUrl": "https://raw.githubusercontent.com/libtmux/assets/55dd6eac4347ba22270788b74a71ec0cba12e287/assets/raku/library/logo.svg",
+  "sourcePage": "https://github.com/libtmux/assets/tree/55dd6eac4347ba22270788b74a71ec0cba12e287/assets/raku",
+  "retrievedAt": "2026-11-13T22:50:00-06:00",
+  "sha256": "d29de9b0d137e07e41e919a1b4e339b3b4f25830320dd47bb503ac6507cd14cb",
+  "copyright": "The libtmux Raku artwork is maintained by the libtmux project.",
+  "license": {
+    "name": "Project-owner artwork; no new license assigned",
+    "urls": [
+      "https://github.com/libtmux/assets/blob/55dd6eac4347ba22270788b74a71ec0cba12e287/THIRD_PARTY.md#libtmux-and-tmuxp"
+    ],
+    "notes": "The source kit assigns no new license to the project owner's artwork or trademarks. Used to identify the Raku port; it is the libtmux library tile, not the Raku language logo, and no endorsement by the Raku project is implied."
+  },
+  "modifications": "None. The reviewed library SVG bytes are preserved.",
+  "upstreamRevision": "55dd6eac4347ba22270788b74a71ec0cba12e287"
+}
diff --git a/site/public/brand/raku/library/app-icon-1024-dark.png b/site/public/brand/raku/library/app-icon-1024-dark.png
new file mode 100644
index 000000000..368174962
Binary files /dev/null and b/site/public/brand/raku/library/app-icon-1024-dark.png differ
diff --git a/site/public/brand/raku/library/app-icon-1024-light.png b/site/public/brand/raku/library/app-icon-1024-light.png
new file mode 100644
index 000000000..9423b2fb3
Binary files /dev/null and b/site/public/brand/raku/library/app-icon-1024-light.png differ
diff --git a/site/public/brand/raku/library/apple-touch-icon-dark.png b/site/public/brand/raku/library/apple-touch-icon-dark.png
new file mode 100644
index 000000000..bcb78b102
Binary files /dev/null and b/site/public/brand/raku/library/apple-touch-icon-dark.png differ
diff --git a/site/public/brand/raku/library/apple-touch-icon-light.png b/site/public/brand/raku/library/apple-touch-icon-light.png
new file mode 100644
index 000000000..3a83c72bd
Binary files /dev/null and b/site/public/brand/raku/library/apple-touch-icon-light.png differ
diff --git a/site/public/brand/raku/library/browserconfig-dark.xml b/site/public/brand/raku/library/browserconfig-dark.xml
new file mode 100644
index 000000000..2eaab55c2
--- /dev/null
+++ b/site/public/brand/raku/library/browserconfig-dark.xml
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><browserconfig><msapplication><tile><square150x150logo src="mstile-150-dark.png"/><square310x310logo src="mstile-310-dark.png"/><TileColor>#0000fb</TileColor></tile></msapplication></browserconfig>
diff --git a/site/public/brand/raku/library/browserconfig.xml b/site/public/brand/raku/library/browserconfig.xml
new file mode 100644
index 000000000..4ccf9586a
--- /dev/null
+++ b/site/public/brand/raku/library/browserconfig.xml
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><browserconfig><msapplication><tile><square150x150logo src="mstile-150-light.png"/><square310x310logo src="mstile-310-light.png"/><TileColor>#0000fb</TileColor></tile></msapplication></browserconfig>
diff --git a/site/public/brand/raku/library/favicon.ico b/site/public/brand/raku/library/favicon.ico
new file mode 100644
index 000000000..014afa1e4
Binary files /dev/null and b/site/public/brand/raku/library/favicon.ico differ
diff --git a/site/public/brand/raku/library/github-social-dark.png b/site/public/brand/raku/library/github-social-dark.png
new file mode 100644
index 000000000..ba721e019
Binary files /dev/null and b/site/public/brand/raku/library/github-social-dark.png differ
diff --git a/site/public/brand/raku/library/github-social-light.png b/site/public/brand/raku/library/github-social-light.png
new file mode 100644
index 000000000..969801deb
Binary files /dev/null and b/site/public/brand/raku/library/github-social-light.png differ
diff --git a/site/public/brand/raku/library/logo-1024.png b/site/public/brand/raku/library/logo-1024.png
new file mode 100644
index 000000000..fef71d6a4
Binary files /dev/null and b/site/public/brand/raku/library/logo-1024.png differ
diff --git a/site/public/brand/raku/library/logo-128.png b/site/public/brand/raku/library/logo-128.png
new file mode 100644
index 000000000..7558367f8
Binary files /dev/null and b/site/public/brand/raku/library/logo-128.png differ
diff --git a/site/public/brand/raku/library/logo-144.png b/site/public/brand/raku/library/logo-144.png
new file mode 100644
index 000000000..c69181f73
Binary files /dev/null and b/site/public/brand/raku/library/logo-144.png differ
diff --git a/site/public/brand/raku/library/logo-152.png b/site/public/brand/raku/library/logo-152.png
new file mode 100644
index 000000000..7cca53998
Binary files /dev/null and b/site/public/brand/raku/library/logo-152.png differ
diff --git a/site/public/brand/raku/library/logo-16.png b/site/public/brand/raku/library/logo-16.png
new file mode 100644
index 000000000..9fc0b452b
Binary files /dev/null and b/site/public/brand/raku/library/logo-16.png differ
diff --git a/site/public/brand/raku/library/logo-167.png b/site/public/brand/raku/library/logo-167.png
new file mode 100644
index 000000000..68f697313
Binary files /dev/null and b/site/public/brand/raku/library/logo-167.png differ
diff --git a/site/public/brand/raku/library/logo-180.png b/site/public/brand/raku/library/logo-180.png
new file mode 100644
index 000000000..5dc8163be
Binary files /dev/null and b/site/public/brand/raku/library/logo-180.png differ
diff --git a/site/public/brand/raku/library/logo-192.png b/site/public/brand/raku/library/logo-192.png
new file mode 100644
index 000000000..29fc59c9d
Binary files /dev/null and b/site/public/brand/raku/library/logo-192.png differ
diff --git a/site/public/brand/raku/library/logo-24.png b/site/public/brand/raku/library/logo-24.png
new file mode 100644
index 000000000..b60ddfebd
Binary files /dev/null and b/site/public/brand/raku/library/logo-24.png differ
diff --git a/site/public/brand/raku/library/logo-256.png b/site/public/brand/raku/library/logo-256.png
new file mode 100644
index 000000000..31076f47c
Binary files /dev/null and b/site/public/brand/raku/library/logo-256.png differ
diff --git a/site/public/brand/raku/library/logo-32.png b/site/public/brand/raku/library/logo-32.png
new file mode 100644
index 000000000..f2b900d00
Binary files /dev/null and b/site/public/brand/raku/library/logo-32.png differ
diff --git a/site/public/brand/raku/library/logo-384.png b/site/public/brand/raku/library/logo-384.png
new file mode 100644
index 000000000..26dc7a087
Binary files /dev/null and b/site/public/brand/raku/library/logo-384.png differ
diff --git a/site/public/brand/raku/library/logo-48.png b/site/public/brand/raku/library/logo-48.png
new file mode 100644
index 000000000..93446ab7d
Binary files /dev/null and b/site/public/brand/raku/library/logo-48.png differ
diff --git a/site/public/brand/raku/library/logo-512.png b/site/public/brand/raku/library/logo-512.png
new file mode 100644
index 000000000..75bb83c43
Binary files /dev/null and b/site/public/brand/raku/library/logo-512.png differ
diff --git a/site/public/brand/raku/library/logo-64.png b/site/public/brand/raku/library/logo-64.png
new file mode 100644
index 000000000..f89019c35
Binary files /dev/null and b/site/public/brand/raku/library/logo-64.png differ
diff --git a/site/public/brand/raku/library/logo-96.png b/site/public/brand/raku/library/logo-96.png
new file mode 100644
index 000000000..abd104631
Binary files /dev/null and b/site/public/brand/raku/library/logo-96.png differ
diff --git a/site/public/brand/raku/library/logo.svg b/site/public/brand/raku/library/logo.svg
new file mode 100644
index 000000000..4ac2b0612
--- /dev/null
+++ b/site/public/brand/raku/library/logo.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 135.46667 135.46666" role="img" aria-label="libtmux for Raku" class="libtmux-logo" data-language="raku" data-variant="library" focusable="false"><title>libtmux for Raku</title><g transform="translate(-210.28959,-409.98108)" data-part="artwork"><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="primary-tile"><path d="M 227.78906,0 213.98242,3.6992188 V 460.62109 H 241.4082 V 15.564453 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#0000B0" data-part="primary-edge"></path><path d="m 210.28981,417.13553 v 113.86425 l 60.26885,2.60089 V 409.98109 h -53.11441 c -3.95129,0 -7.15444,3.20315 -7.15444,7.15444 z" fill="#0000fb" data-part="primary"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="lower-tile"><path d="m 486.38086,246.03906 -5.24805,4.99805 v 207.2207 l 5.24805,-0.93164 L 500,465.18945 V 261.60352 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#000071" data-part="lower-edge"></path><path d="m 278.70874,475.07917 v 64.8875 l 60.26883,-8.98455 v -55.90295 z" fill="#0000A3" data-part="lower"></path></g><path d="m 210.28959,533.88585 v 4.23589 c 9e-5,4.04619 3.2803,7.32617 7.32649,7.32598 h 28.63105 l 81.26967,-1.0223 14.5495,-10.53906 v 0 z" fill="#231F20" data-part="base"></path><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="upper-tile"><path d="m 459.33984,0 -25.33593,2.1074219 h 21.38281 c 14.93397,0 27.04101,12.1070061 27.04101,27.0410161 V 129.83008 l 6.17579,13.24609 L 500,112.43359 V 42.603516 C 499.99913,8.8176763 474.27408,-6.8031496e-4 459.33984,0 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#4040FC" data-part="upper-side"></path><path d="m 331.82331,409.98109 h -53.11442 v 56.93261 h 60.26885 v -49.77817 c 0,-3.95129 -3.20315,-7.15444 -7.15443,-7.15444 z" fill="#8C8CFD" data-part="upper"></path><path d="m 278.7089,466.9137 h 60.26885 l 3.6035,4.11782 h -60.26932 z" fill="#0000E2" data-part="upper-bottom"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="gear-group"><path d="m 298.35661,419.37889 c -3.307,0 -6.01087,2.63649 -6.0946,5.94228 l -0.33026,13.04677 c -0.0503,1.98883 -1.3048,3.74588 -3.16843,4.44175 -1.63527,0.6105 -3.23561,1.29298 -4.79768,2.04293 -1.82786,0.87796 -4.00547,0.54134 -5.47527,-0.85609 l -9.17457,-8.72115 c -2.39692,-2.27863 -6.17361,-2.23122 -8.512,0.10759 l -14.3945,14.39447 c -1.27625,1.27604 -1.86544,2.98029 -1.77147,4.65491 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22023 -0.0123,0.44029 0,0.66053 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0838,1.61437 0.46467,3.25669 1.6634,4.51768 l 8.99461,9.46208 c 0.23074,0.24278 0.42181,0.51038 0.59418,0.78721 -0.60023,1.35769 -1.15279,2.74067 -1.64984,4.15071 -0.6727,1.90958 -2.45019,3.20822 -4.47443,3.25942 l -12.65165,0.31971 c -3.30618,0.0837 -5.94279,2.7886 -5.94279,6.0956 v 0.66053 0.66053 0.66053 0.66056 2.64112 15.07361 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 c 0,3.30703 2.63661,6.01136 5.94279,6.09511 l 13.04677,0.32975 c 1.98885,0.0503 3.74539,1.30529 4.44124,3.16895 0.53531,1.43379 1.12957,2.83886 1.7725,4.21655 -0.17026,0.27145 -0.35881,0.53398 -0.58564,0.77264 l -8.72163,9.17405 c -1.19922,1.26148 -1.74723,2.90475 -1.66291,4.51969 -0.0124,0.22024 -0.0118,0.44029 0,0.66053 v 0.0457 h 0.0875 l 10.03868,-9.51839 29.63949,8.95286 h 43.47603 l 13.935,-16.69426 v -0.0216 c -8.04912,9.72841 -20.24315,15.90068 -33.88319,15.7844 -22.83086,-0.19494 -41.62302,-18.24181 -43.0251,-40.7806 1.34121,-22.94291 20.4588,-41.11551 43.78415,-40.91631 13.2902,0.11325 25.20451,6.28323 33.12414,15.86034 v -3.90741 -20.27843 -11.02398 l -3.97024,3.7742 c -1.44419,1.37264 -3.57681,1.72648 -5.38882,0.89729 -1.57465,-0.72024 -3.18724,-1.3729 -4.83384,-1.95295 -1.90955,-0.67268 -3.2077,-2.45012 -3.25892,-4.47392 l -0.32023,-12.65265 c -0.0836,-3.30579 -2.78757,-5.94228 -6.09457,-5.94228 z" fill="#999999" data-part="gear-edge"></path><path d="m 298.35715,419.3789 c -3.30703,0 -6.01139,2.63697 -6.09511,5.94277 l -0.33075,13.04677 c -0.0504,1.98885 -1.30431,3.74539 -3.16795,4.44126 -1.63521,0.6105 -3.23553,1.29298 -4.79716,2.04293 -1.8283,0.87755 -4.0065,0.54134 -5.47627,-0.85609 l -9.17408,-8.72115 c -2.39692,-2.27863 -6.17372,-2.23122 -8.51252,0.10759 l -14.39447,14.39498 c -2.33842,2.33839 -2.38624,6.1146 -0.10759,8.51152 l 8.9951,9.46211 c 1.37305,1.44416 1.72558,3.57678 0.89681,5.38881 -0.72068,1.57466 -1.37293,3.18676 -1.95295,4.83335 -0.67271,1.90958 -2.45022,3.20823 -4.47444,3.25942 l -12.65164,0.32023 c -3.30621,0.0837 -5.9428,2.78759 -5.9428,6.09459 v 20.35786 c 0,3.30703 2.63659,6.01087 5.9428,6.09459 l 13.04677,0.33027 c 1.98843,0.0504 3.74578,1.30479 4.44123,3.16846 0.61094,1.63521 1.29301,3.2356 2.04295,4.79765 0.87797,1.82789 0.54145,4.00591 -0.85559,5.47527 l -8.72164,9.17457 c -1.37514,1.44653 -1.88755,3.39384 -1.57592,5.22595 h 0.7465 24.32055 61.26465 3.60327 c 3.95126,0 7.15424,-3.20297 7.15424,-7.15427 v -2.056 -8.04952 c -8.05257,9.71866 -20.25002,15.87899 -33.88271,15.76278 -23.61284,-0.2016 -42.90943,-19.4986 -43.11104,-43.11106 -0.20729,-24.31847 19.55063,-44.07731 43.86912,-43.8696 13.28515,0.11319 25.2041,6.27146 33.12463,15.84172 v -18.88347 -11.02398 l -3.97073,3.77469 c -1.44417,1.37264 -3.57578,1.72599 -5.38782,0.8968 -1.57506,-0.72024 -3.18776,-1.37292 -4.83435,-1.95295 -1.90958,-0.67309 -3.20729,-2.45063 -3.25892,-4.47441 l -0.32023,-12.65167 c -0.0833,-3.3058 -2.78767,-5.94277 -6.09509,-5.94277 z" fill="#E6E6E6" data-part="gear"></path></g></g></svg>
diff --git a/site/public/brand/raku/library/maskable-192-dark.png b/site/public/brand/raku/library/maskable-192-dark.png
new file mode 100644
index 000000000..5287073a9
Binary files /dev/null and b/site/public/brand/raku/library/maskable-192-dark.png differ
diff --git a/site/public/brand/raku/library/maskable-192-light.png b/site/public/brand/raku/library/maskable-192-light.png
new file mode 100644
index 000000000..3bba98907
Binary files /dev/null and b/site/public/brand/raku/library/maskable-192-light.png differ
diff --git a/site/public/brand/raku/library/maskable-512-dark.png b/site/public/brand/raku/library/maskable-512-dark.png
new file mode 100644
index 000000000..6c0c186cc
Binary files /dev/null and b/site/public/brand/raku/library/maskable-512-dark.png differ
diff --git a/site/public/brand/raku/library/maskable-512-light.png b/site/public/brand/raku/library/maskable-512-light.png
new file mode 100644
index 000000000..3b6ac3caf
Binary files /dev/null and b/site/public/brand/raku/library/maskable-512-light.png differ
diff --git a/site/public/brand/raku/library/mstile-150-dark.png b/site/public/brand/raku/library/mstile-150-dark.png
new file mode 100644
index 000000000..8f2be1c65
Binary files /dev/null and b/site/public/brand/raku/library/mstile-150-dark.png differ
diff --git a/site/public/brand/raku/library/mstile-150-light.png b/site/public/brand/raku/library/mstile-150-light.png
new file mode 100644
index 000000000..424cc0ce1
Binary files /dev/null and b/site/public/brand/raku/library/mstile-150-light.png differ
diff --git a/site/public/brand/raku/library/mstile-310-dark.png b/site/public/brand/raku/library/mstile-310-dark.png
new file mode 100644
index 000000000..92eb441e9
Binary files /dev/null and b/site/public/brand/raku/library/mstile-310-dark.png differ
diff --git a/site/public/brand/raku/library/mstile-310-light.png b/site/public/brand/raku/library/mstile-310-light.png
new file mode 100644
index 000000000..e4705e8ce
Binary files /dev/null and b/site/public/brand/raku/library/mstile-310-light.png differ
diff --git a/site/public/brand/raku/library/opengraph-dark.jpg b/site/public/brand/raku/library/opengraph-dark.jpg
new file mode 100644
index 000000000..075d57e52
Binary files /dev/null and b/site/public/brand/raku/library/opengraph-dark.jpg differ
diff --git a/site/public/brand/raku/library/opengraph-dark.png b/site/public/brand/raku/library/opengraph-dark.png
new file mode 100644
index 000000000..4a362f214
Binary files /dev/null and b/site/public/brand/raku/library/opengraph-dark.png differ
diff --git a/site/public/brand/raku/library/opengraph-light.jpg b/site/public/brand/raku/library/opengraph-light.jpg
new file mode 100644
index 000000000..fdaab1547
Binary files /dev/null and b/site/public/brand/raku/library/opengraph-light.jpg differ
diff --git a/site/public/brand/raku/library/opengraph-light.png b/site/public/brand/raku/library/opengraph-light.png
new file mode 100644
index 000000000..3454d3897
Binary files /dev/null and b/site/public/brand/raku/library/opengraph-light.png differ
diff --git a/site/public/brand/raku/library/safari-pinned-tab.svg b/site/public/brand/raku/library/safari-pinned-tab.svg
new file mode 100644
index 000000000..259e4a029
--- /dev/null
+++ b/site/public/brand/raku/library/safari-pinned-tab.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 135.46667 135.46666" role="img" aria-label="libtmux for Raku" class="libtmux-logo" data-language="raku" data-variant="library" focusable="false"><title>libtmux for Raku</title><g transform="translate(-210.28959,-409.98108)" data-part="artwork"><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="primary-tile"><path d="M 227.78906,0 213.98242,3.6992188 V 460.62109 H 241.4082 V 15.564453 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#000000" data-part="primary-edge"></path><path d="m 210.28981,417.13553 v 113.86425 l 60.26885,2.60089 V 409.98109 h -53.11441 c -3.95129,0 -7.15444,3.20315 -7.15444,7.15444 z" fill="#000000" data-part="primary"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="lower-tile"><path d="m 486.38086,246.03906 -5.24805,4.99805 v 207.2207 l 5.24805,-0.93164 L 500,465.18945 V 261.60352 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#000000" data-part="lower-edge"></path><path d="m 278.70874,475.07917 v 64.8875 l 60.26883,-8.98455 v -55.90295 z" fill="#000000" data-part="lower"></path></g><path d="m 210.28959,533.88585 v 4.23589 c 9e-5,4.04619 3.2803,7.32617 7.32649,7.32598 h 28.63105 l 81.26967,-1.0223 14.5495,-10.53906 v 0 z" fill="#000000" data-part="base"></path><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="upper-tile"><path d="m 459.33984,0 -25.33593,2.1074219 h 21.38281 c 14.93397,0 27.04101,12.1070061 27.04101,27.0410161 V 129.83008 l 6.17579,13.24609 L 500,112.43359 V 42.603516 C 499.99913,8.8176763 474.27408,-6.8031496e-4 459.33984,0 Z" transform="matrix(0.26458333,0,0,0.26458333,210.28959,409.98108)" fill="#000000" data-part="upper-side"></path><path d="m 331.82331,409.98109 h -53.11442 v 56.93261 h 60.26885 v -49.77817 c 0,-3.95129 -3.20315,-7.15444 -7.15443,-7.15444 z" fill="#000000" data-part="upper"></path><path d="m 278.7089,466.9137 h 60.26885 l 3.6035,4.11782 h -60.26932 z" fill="#000000" data-part="upper-bottom"></path></g><g transform="matrix(1.024,0,0,1.0240011,-5.0469507,-9.8399997)" data-part="gear-group"><path d="m 298.35661,419.37889 c -3.307,0 -6.01087,2.63649 -6.0946,5.94228 l -0.33026,13.04677 c -0.0503,1.98883 -1.3048,3.74588 -3.16843,4.44175 -1.63527,0.6105 -3.23561,1.29298 -4.79768,2.04293 -1.82786,0.87796 -4.00547,0.54134 -5.47527,-0.85609 l -9.17457,-8.72115 c -2.39692,-2.27863 -6.17361,-2.23122 -8.512,0.10759 l -14.3945,14.39447 c -1.27625,1.27604 -1.86544,2.98029 -1.77147,4.65491 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22023 -0.0123,0.44029 0,0.66053 -0.0118,0.22021 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0118,0.22024 -0.0123,0.44029 0,0.66053 -0.0838,1.61437 0.46467,3.25669 1.6634,4.51768 l 8.99461,9.46208 c 0.23074,0.24278 0.42181,0.51038 0.59418,0.78721 -0.60023,1.35769 -1.15279,2.74067 -1.64984,4.15071 -0.6727,1.90958 -2.45019,3.20822 -4.47443,3.25942 l -12.65165,0.31971 c -3.30618,0.0837 -5.94279,2.7886 -5.94279,6.0956 v 0.66053 0.66053 0.66053 0.66056 2.64112 15.07361 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 0.66053 c 0,3.30703 2.63661,6.01136 5.94279,6.09511 l 13.04677,0.32975 c 1.98885,0.0503 3.74539,1.30529 4.44124,3.16895 0.53531,1.43379 1.12957,2.83886 1.7725,4.21655 -0.17026,0.27145 -0.35881,0.53398 -0.58564,0.77264 l -8.72163,9.17405 c -1.19922,1.26148 -1.74723,2.90475 -1.66291,4.51969 -0.0124,0.22024 -0.0118,0.44029 0,0.66053 v 0.0457 h 0.0875 l 10.03868,-9.51839 29.63949,8.95286 h 43.47603 l 13.935,-16.69426 v -0.0216 c -8.04912,9.72841 -20.24315,15.90068 -33.88319,15.7844 -22.83086,-0.19494 -41.62302,-18.24181 -43.0251,-40.7806 1.34121,-22.94291 20.4588,-41.11551 43.78415,-40.91631 13.2902,0.11325 25.20451,6.28323 33.12414,15.86034 v -3.90741 -20.27843 -11.02398 l -3.97024,3.7742 c -1.44419,1.37264 -3.57681,1.72648 -5.38882,0.89729 -1.57465,-0.72024 -3.18724,-1.3729 -4.83384,-1.95295 -1.90955,-0.67268 -3.2077,-2.45012 -3.25892,-4.47392 l -0.32023,-12.65265 c -0.0836,-3.30579 -2.78757,-5.94228 -6.09457,-5.94228 z" fill="#000000" data-part="gear-edge"></path><path d="m 298.35715,419.3789 c -3.30703,0 -6.01139,2.63697 -6.09511,5.94277 l -0.33075,13.04677 c -0.0504,1.98885 -1.30431,3.74539 -3.16795,4.44126 -1.63521,0.6105 -3.23553,1.29298 -4.79716,2.04293 -1.8283,0.87755 -4.0065,0.54134 -5.47627,-0.85609 l -9.17408,-8.72115 c -2.39692,-2.27863 -6.17372,-2.23122 -8.51252,0.10759 l -14.39447,14.39498 c -2.33842,2.33839 -2.38624,6.1146 -0.10759,8.51152 l 8.9951,9.46211 c 1.37305,1.44416 1.72558,3.57678 0.89681,5.38881 -0.72068,1.57466 -1.37293,3.18676 -1.95295,4.83335 -0.67271,1.90958 -2.45022,3.20823 -4.47444,3.25942 l -12.65164,0.32023 c -3.30621,0.0837 -5.9428,2.78759 -5.9428,6.09459 v 20.35786 c 0,3.30703 2.63659,6.01087 5.9428,6.09459 l 13.04677,0.33027 c 1.98843,0.0504 3.74578,1.30479 4.44123,3.16846 0.61094,1.63521 1.29301,3.2356 2.04295,4.79765 0.87797,1.82789 0.54145,4.00591 -0.85559,5.47527 l -8.72164,9.17457 c -1.37514,1.44653 -1.88755,3.39384 -1.57592,5.22595 h 0.7465 24.32055 61.26465 3.60327 c 3.95126,0 7.15424,-3.20297 7.15424,-7.15427 v -2.056 -8.04952 c -8.05257,9.71866 -20.25002,15.87899 -33.88271,15.76278 -23.61284,-0.2016 -42.90943,-19.4986 -43.11104,-43.11106 -0.20729,-24.31847 19.55063,-44.07731 43.86912,-43.8696 13.28515,0.11319 25.2041,6.27146 33.12463,15.84172 v -18.88347 -11.02398 l -3.97073,3.77469 c -1.44417,1.37264 -3.57578,1.72599 -5.38782,0.8968 -1.57506,-0.72024 -3.18776,-1.37292 -4.83435,-1.95295 -1.90958,-0.67309 -3.20729,-2.45063 -3.25892,-4.47441 l -0.32023,-12.65167 c -0.0833,-3.3058 -2.78767,-5.94277 -6.09509,-5.94277 z" fill="#000000" data-part="gear"></path></g></g></svg>
diff --git a/site/public/brand/raku/library/site-dark.webmanifest b/site/public/brand/raku/library/site-dark.webmanifest
new file mode 100644
index 000000000..d5a062df1
--- /dev/null
+++ b/site/public/brand/raku/library/site-dark.webmanifest
@@ -0,0 +1,36 @@
+{
+  "name": "libtmux for Raku",
+  "short_name": "libtmux",
+  "id": "/",
+  "start_url": "../../../",
+  "scope": "../../../",
+  "display": "browser",
+  "background_color": "#12161D",
+  "theme_color": "#0000fb",
+  "icons": [
+    {
+      "src": "logo-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "maskable-192-dark.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "maskable"
+    },
+    {
+      "src": "logo-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "maskable-512-dark.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}
diff --git a/site/public/brand/raku/library/site.webmanifest b/site/public/brand/raku/library/site.webmanifest
new file mode 100644
index 000000000..c95314bec
--- /dev/null
+++ b/site/public/brand/raku/library/site.webmanifest
@@ -0,0 +1,36 @@
+{
+  "name": "libtmux for Raku",
+  "short_name": "libtmux",
+  "id": "/",
+  "start_url": "../../../",
+  "scope": "../../../",
+  "display": "browser",
+  "background_color": "#F4F4F1",
+  "theme_color": "#0000fb",
+  "icons": [
+    {
+      "src": "logo-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "maskable-192-light.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "maskable"
+    },
+    {
+      "src": "logo-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "maskable-512-light.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}
diff --git a/site/public/brand/raku/library/social-square-dark.png b/site/public/brand/raku/library/social-square-dark.png
new file mode 100644
index 000000000..a251d10e5
Binary files /dev/null and b/site/public/brand/raku/library/social-square-dark.png differ
diff --git a/site/public/brand/raku/library/social-square-light.png b/site/public/brand/raku/library/social-square-light.png
new file mode 100644
index 000000000..8a629086b
Binary files /dev/null and b/site/public/brand/raku/library/social-square-light.png differ
diff --git a/site/public/brand/raku/library/twitter-dark.png b/site/public/brand/raku/library/twitter-dark.png
new file mode 100644
index 000000000..68dc6020e
Binary files /dev/null and b/site/public/brand/raku/library/twitter-dark.png differ
diff --git a/site/public/brand/raku/library/twitter-light.png b/site/public/brand/raku/library/twitter-light.png
new file mode 100644
index 000000000..00ff01e03
Binary files /dev/null and b/site/public/brand/raku/library/twitter-light.png differ
diff --git a/site/public/brand/raku/source.json b/site/public/brand/raku/source.json
new file mode 100644
index 000000000..8500b5f0f
--- /dev/null
+++ b/site/public/brand/raku/source.json
@@ -0,0 +1,249 @@
+{
+  "schemaVersion": 1,
+  "repository": "https://github.com/libtmux/assets",
+  "revision": "55dd6eac4347ba22270788b74a71ec0cba12e287",
+  "language": "raku",
+  "primary": "#0000fb",
+  "githubLanguageColors": "https://github.com/github-linguist/linguist/blob/d456527fe93355baa28c3c29d542c97282b61bc7/lib/linguist/languages.yml",
+  "sourceDirectory": "assets/raku",
+  "variants": [
+    "library"
+  ],
+  "manifestOverrides": {
+    "files": [
+      "site.webmanifest",
+      "site-dark.webmanifest"
+    ],
+    "id": "/",
+    "start_url": "../../../",
+    "scope": "../../../",
+    "display": "browser"
+  },
+  "sourceFiles": [
+    {
+      "file": "library/logo.svg",
+      "bytes": 5879,
+      "sha256": "d29de9b0d137e07e41e919a1b4e339b3b4f25830320dd47bb503ac6507cd14cb"
+    },
+    {
+      "file": "library/logo-16.png",
+      "bytes": 563,
+      "sha256": "66dff74ed31f19515d4fe93f7e2a37647c600cf92ecea3902fc3a4a3c4b68545"
+    },
+    {
+      "file": "library/logo-24.png",
+      "bytes": 751,
+      "sha256": "4a7ac0dd1d229e62d9d92930e331db00a762527103b3840a34e638f5e4d0ea79"
+    },
+    {
+      "file": "library/logo-32.png",
+      "bytes": 1009,
+      "sha256": "6ff0537aa942c284f50ece1fae4a244d368280522c0447a86082b55319657807"
+    },
+    {
+      "file": "library/logo-48.png",
+      "bytes": 1458,
+      "sha256": "162feed5b2a715fd7cf830e72d141f972465b48a62ca942d7310739f09335228"
+    },
+    {
+      "file": "library/logo-64.png",
+      "bytes": 1887,
+      "sha256": "23408529a0e37c98f695ffdc1fd407caff307ba1f554bdfeca57ce765392b0f7"
+    },
+    {
+      "file": "library/logo-96.png",
+      "bytes": 2725,
+      "sha256": "6688886c3505b05eb8d0591a058a4ece1920da6a80ddbc84a4a3fa60e026d67b"
+    },
+    {
+      "file": "library/logo-128.png",
+      "bytes": 3644,
+      "sha256": "0fedf8ae7574d25038463e5eb77a1f9587d4ea4fbe36839c68f4074de7b2ed1b"
+    },
+    {
+      "file": "library/logo-144.png",
+      "bytes": 4092,
+      "sha256": "0c8533c0bdac2f4cfedd4741e3a34b51d9116481dc4e640058cff41f6df704ed"
+    },
+    {
+      "file": "library/logo-152.png",
+      "bytes": 4241,
+      "sha256": "2b97c3cc942a8a34db6268164b264f02f5b7030b5870a0a612b24d6b46608a73"
+    },
+    {
+      "file": "library/logo-167.png",
+      "bytes": 4680,
+      "sha256": "8e23cf4bab3145d61abee4da34c26caa6711d9b2993f8b81a39677b52bcb5b4f"
+    },
+    {
+      "file": "library/logo-180.png",
+      "bytes": 5176,
+      "sha256": "41478eed635a47867e9c5e2fd81ad518f56e1aca7dfce45e62b72e1fdba74312"
+    },
+    {
+      "file": "library/logo-192.png",
+      "bytes": 5499,
+      "sha256": "9faaf59f1c1b708418480c346ebd80bbe22425addf1db455b493f1fa0df88196"
+    },
+    {
+      "file": "library/logo-256.png",
+      "bytes": 7440,
+      "sha256": "fde027226f1f7b33dc07f64a5fb660cb5e220dd76e948b4518fc7278874cf3da"
+    },
+    {
+      "file": "library/logo-384.png",
+      "bytes": 11534,
+      "sha256": "03a10bcb4c5e508b407eedcf9136d1d46cde4e7daf86f8243245bad596ce451e"
+    },
+    {
+      "file": "library/logo-512.png",
+      "bytes": 15988,
+      "sha256": "4cb45d5d6f0a33c479795a32a58d3e44a7dd2d2e0c1bbfd1baa975d5e1c50483"
+    },
+    {
+      "file": "library/logo-1024.png",
+      "bytes": 36310,
+      "sha256": "905f7c9f105d85a332b120598b8f59eafe0d2c5da725909a7e1167043f3b1b04"
+    },
+    {
+      "file": "library/favicon.ico",
+      "bytes": 22542,
+      "sha256": "d32346301b8c95f4074c42382eab7d518758b10035225723acbda69ee1022f05"
+    },
+    {
+      "file": "library/safari-pinned-tab.svg",
+      "bytes": 5879,
+      "sha256": "290b7e5f70062386563d6bf4f5768ed6605a618cd3b608354ca600d68616284f"
+    },
+    {
+      "file": "library/apple-touch-icon-light.png",
+      "bytes": 3857,
+      "sha256": "031004f812ad5dad209c82d881fdd8853d3784064425e88726c531cc1881270d"
+    },
+    {
+      "file": "library/app-icon-1024-light.png",
+      "bytes": 28394,
+      "sha256": "86a140bd45afd5c4450bae7f864d60cfd0a25b1d7d3f76a8dd32f110c77546be"
+    },
+    {
+      "file": "library/maskable-192-light.png",
+      "bytes": 3084,
+      "sha256": "2588e7514f9531b86ee2a1826f0833d95c79290c54293ebf6f580303d9b220ea"
+    },
+    {
+      "file": "library/maskable-512-light.png",
+      "bytes": 9293,
+      "sha256": "9cf9371c9ff12256ea235f4b59508294dc0e60488d04634118536879d1f97faa"
+    },
+    {
+      "file": "library/mstile-150-light.png",
+      "bytes": 2999,
+      "sha256": "dcd60dcd8e347e4bae3a649d4104c9caf11f39f2f6b1b06e800ad2eeb77ea43e"
+    },
+    {
+      "file": "library/mstile-310-light.png",
+      "bytes": 6525,
+      "sha256": "18ef095ad71e0d2f320a209d7b1b9d59ed6bf7576b4333b9f0cc2b543c2981d3"
+    },
+    {
+      "file": "library/opengraph-light.png",
+      "bytes": 25134,
+      "sha256": "9ac90c0cbc233162bc71d1de93466736171dc6aac90090466100dc8b54a8fc39"
+    },
+    {
+      "file": "library/opengraph-light.jpg",
+      "bytes": 46117,
+      "sha256": "e27ee0a46b91971d8dd95150b7ecffde754b1aa47c40d7e884aabdc64688ffba"
+    },
+    {
+      "file": "library/twitter-light.png",
+      "bytes": 24965,
+      "sha256": "760d706412948ca09da22cfcdd41884ca6d5b5538cbf1bb391733f6e8e23d7f9"
+    },
+    {
+      "file": "library/social-square-light.png",
+      "bytes": 28890,
+      "sha256": "0e2c83ef136c6f516629e858357db97e3f375b77551dad9eebaab90c0fb9ec71"
+    },
+    {
+      "file": "library/site.webmanifest",
+      "bytes": 716,
+      "sha256": "3bf9f40554b13ee88a31c13c126b1d319bcb5dbb56cf61d2ef2e827074d94dab"
+    },
+    {
+      "file": "library/browserconfig.xml",
+      "bytes": 238,
+      "sha256": "a275b5bf7cf9484884c1fd85f2aaeead64e4eef44785c7390f715bc81c4dbd87"
+    },
+    {
+      "file": "library/apple-touch-icon-dark.png",
+      "bytes": 3873,
+      "sha256": "abb814cf8cd8d691d028d6848fb1c6f62b873511c19febdb22b53086c2fe02f6"
+    },
+    {
+      "file": "library/app-icon-1024-dark.png",
+      "bytes": 28683,
+      "sha256": "5873a255a31c9e94e7fb9077016deecb39c3fe3cbff811eb9e0ef0d4d6d668c8"
+    },
+    {
+      "file": "library/maskable-192-dark.png",
+      "bytes": 3114,
+      "sha256": "02cf7a6a92a5f2f1682b2f3fa1547cd2397003ed17ff27cfdb69f093edc28a81"
+    },
+    {
+      "file": "library/maskable-512-dark.png",
+      "bytes": 9375,
+      "sha256": "42bcd9ff5f1c960c1bb9019eb9d235cb5e49db703fc4361c04d6d22c59037834"
+    },
+    {
+      "file": "library/mstile-150-dark.png",
+      "bytes": 3024,
+      "sha256": "f4b4fabf34865a50077a5e96ded570e095eb66033d0b7e259636f36ac442bf2e"
+    },
+    {
+      "file": "library/mstile-310-dark.png",
+      "bytes": 6578,
+      "sha256": "01be9b8ce61c01349e8f490ebd4c41a95c745d43471358f563b006d89d14d198"
+    },
+    {
+      "file": "library/opengraph-dark.png",
+      "bytes": 25396,
+      "sha256": "660ef6b57a1c45657fad9229d45b132c35d95346063278e1fd4969e8ff5f0a3b"
+    },
+    {
+      "file": "library/opengraph-dark.jpg",
+      "bytes": 43791,
+      "sha256": "cc6971140c97e02ce7f334bc231e1124bc5afa8151023a7260cb76e161a25ff3"
+    },
+    {
+      "file": "library/twitter-dark.png",
+      "bytes": 25219,
+      "sha256": "85b09f4c814224590c2c8bb02037cf3e2ba90b10d46ac972aaac751770bb5b50"
+    },
+    {
+      "file": "library/social-square-dark.png",
+      "bytes": 29151,
+      "sha256": "a9fca634a2ef64b844c7627dddfe9ad790804201ee96dbec54e156a30d9be93c"
+    },
+    {
+      "file": "library/site-dark.webmanifest",
+      "bytes": 714,
+      "sha256": "a95d23a5948ae8702adcf2b737221012f844a7e5215250bb813b87fbd2476e0e"
+    },
+    {
+      "file": "library/browserconfig-dark.xml",
+      "bytes": 236,
+      "sha256": "1fa4e33a8b34b8f169bcc71d3246f5c398412645aa19fb05c638a43b75ae13bf"
+    },
+    {
+      "file": "library/github-social-dark.png",
+      "bytes": 25777,
+      "sha256": "2af6f52eeddd561bce31d795ec2e5fb2444e214360ab3830bd0b1cac981dc1fc"
+    },
+    {
+      "file": "library/github-social-light.png",
+      "bytes": 25516,
+      "sha256": "c348d034527fddae0735ce160632af604bb0c24298a1152067c9125f707b7328"
+    }
+  ]
+}
diff --git a/site/public/versions.json b/site/public/versions.json
index 9e0c4bdd9..655aed2ac 100644
--- a/site/public/versions.json
+++ b/site/public/versions.json
@@ -176,6 +176,14 @@
         "kind": "trunk",
         "supported": true
       }
+    ],
+    "raku": [
+      {
+        "slug": "latest",
+        "label": "latest",
+        "kind": "trunk",
+        "supported": true
+      }
     ]
   },
   "defaultVersion": {
@@ -200,6 +208,7 @@
     "perl": "latest",
     "clojure": "latest",
     "lisp": "latest",
-    "erlang": "latest"
+    "erlang": "latest",
+    "raku": "latest"
   }
 }
diff --git a/site/src/components/CoreHome.astro b/site/src/components/CoreHome.astro
index 30b0f52cb..23083f588 100644
--- a/site/src/components/CoreHome.astro
+++ b/site/src/components/CoreHome.astro
@@ -46,7 +46,8 @@ const PINS: Record<string, { lang: string; code: (name: string, series: string,
   hex: { lang: 'elixir', code: (name, _s, v) => `{:${name}, "~> ${v}"}` },
   nuget: { lang: 'xml', code: (name, s, v) => `<PackageReference Include="${name}" Version="[${v},${s.replace(/\d+$/, (n) => String(Number(n) + 1))})" />` },
 }
-const pin = series && info.slug !== 'py' && info.registry ? PINS[info.registry.icon] : undefined
+// Erlang's install already pins an exact version, and its Hex entry is not an Elixir tuple.
+const pin = series && info.slug !== 'py' && info.slug !== 'erlang' && info.registry ? PINS[info.registry.icon] : undefined
 const capabilityOf = (key: string) => [...home.capabilities.typed, ...home.capabilities.cli].find((row) => row.key === key)
 const location = capabilityOf('current-pane')
 const testing = capabilityOf('test-fixtures')
diff --git a/site/src/components/api/ApiEntry.astro b/site/src/components/api/ApiEntry.astro
index 088c2aff6..705b4895f 100644
--- a/site/src/components/api/ApiEntry.astro
+++ b/site/src/components/api/ApiEntry.astro
@@ -24,6 +24,7 @@ import ApiSignatureParameters from './ApiSignatureParameters.astro'
 import { apiSignatureLayouts } from '../../lib/code-layout'
 import { pythonSignatureLayout } from '../../lib/python-code-layout'
 import { nativeKind } from '../../lib/api-labels'
+import type { ApiAlternate } from '../../lib/perl-pod'
 
 /**
  * One documented symbol, in the shape gp-sphinx's stylesheet expects.
@@ -43,6 +44,8 @@ interface Props {
   index: SymbolIndex
   /** Repository blob URL builder, for the source link. */
   sourceUrl?: (symbol: ApiSymbol) => string | undefined
+  /** The same declaration in the ecosystem's own documentation, when the ecosystem hosts it and the host documents it. */
+  alternate?: (symbol: ApiSymbol) => ApiAlternate | undefined
   /** This entry's port. Enables the cross-language block; omit to hide it. */
   port?: string
   /** Declaration syntax, independent of library-port identity. */
@@ -86,7 +89,7 @@ interface Props {
    */
   linkRows?: boolean
 }
-const { symbol, parentKind, index, sourceUrl, port, language = port, manualLinks, catalogLinks, alternativesFor, heading = false, member = false,
+const { symbol, parentKind, index, sourceUrl, alternate: alternateFor, port, language = port, manualLinks, catalogLinks, alternativesFor, heading = false, member = false,
   showSummary = true, showBases = true, legacyId, nameHref, linkRows = true } = Astro.props as Props
 const anchor = symbol.publicId ?? symbol.id
 const inventory = apiInventoryAttributes(symbol, language ?? '', parentKind ?? (symbol.parent ? API_MODELS[port ?? '']?.symbols.find((parent) => parent.id === symbol.parent)?.kind : undefined))
@@ -158,6 +161,7 @@ const inheritedHref = symbol.inheritedFrom
  * entry already says which class that is.
  */
 const source = sourceUrl?.(symbol)
+const alternate = alternateFor?.(symbol)
 
 /** The keyword a declaration of this kind opens with, where one exists. */
 const KEYWORD: Record<string, string> = {
@@ -425,9 +429,13 @@ const hasBody =
            * this an inline-flex item in the header row still applies; only
            * the anchor inside it is new.
            */
-          source && (
+          (source || alternate) && (
             <span class="gp-sphinx-api-source-link viewcode-link">
-              <span class="pre">[<a class="api-source-anchor" href={source}>source</a>]</span>
+              {source && <span class="pre">[<a class="api-source-anchor" href={source}>source</a>]</span>}
+              {alternate && (
+                <span class="pre api-alternate-link" data-alternate-docs={alternate.kind} data-alternate-observation={alternate.differs ? 'release' : 'source'}>[<a
+                  class="api-source-anchor api-alternate-anchor" href={alternate.href} rel="noopener" title={alternate.title} aria-label={alternate.title}>{alternate.label}</a>]</span>
+              )}
             </span>
           )
         }
diff --git a/site/src/components/api/ApiReference.astro b/site/src/components/api/ApiReference.astro
index 95ffc4b2f..8a8cef767 100644
--- a/site/src/components/api/ApiReference.astro
+++ b/site/src/components/api/ApiReference.astro
@@ -28,6 +28,7 @@ import { withRoot } from '../../lib/site-root'
 import { API_MODELS, API_NAV, PORT_NAME, indexFor, isMemberOwner, ownersOf, pageSlug, referenceAlternatives, topLevelTypesOf } from '../../lib/api-models'
 import { PORT_BY_SLUG, referenceUrl } from '../../lib/ports'
 import { productApiHref } from '../../lib/product-api'
+import { alternateDocs } from '../../lib/perl-pod'
 import { nativeQualifiedName, nativeShortName } from '../../lib/native-name'
 import { nativeKind } from '../../lib/api-labels'
 import { plainMention } from '../../lib/mention-badge'
@@ -794,6 +795,7 @@ const bases = owner && 'extends' in owner ? owner.extends ?? [] : []
                 parentKind={declaringType?.kind}
                 index={index}
                 sourceUrl={sourceUrl}
+                alternate={(entry) => portModel ? alternateDocs(portModel, entry, version) : undefined}
                 port={port}
                 language={language}
                 manualLinks={source?.manualLinks}
diff --git a/site/src/components/api/ProductApiPage.astro b/site/src/components/api/ProductApiPage.astro
index 72063760d..439b36971 100644
--- a/site/src/components/api/ProductApiPage.astro
+++ b/site/src/components/api/ProductApiPage.astro
@@ -11,6 +11,7 @@ import { apiTmuxSections } from '../../lib/api-tmux-sections'
 import { productApiAlternatives, productApiHref, productApiIndex } from '../../lib/product-api'
 import { DOC_PRODUCTS, PORT_BY_SLUG, portPageUrl, productApiPath, type DocProduct } from '../../lib/ports'
 import { symbolSource } from '../../lib/markdown-twins'
+import { alternateDocs } from '../../lib/perl-pod'
 import '../../styles/api.css'
 import '../../styles/vendor/gp-sphinx-api.css'
 interface Props { model: ApiModel; symbol: ApiSymbol; version: string }
@@ -54,7 +55,8 @@ const tmuxSections = apiTmuxSections(model.port, symbol, alternativesFor(symbol)
   pageSource={symbolSource(model, symbol)} markdown="source">
   <div class="api-reference-content not-prose">
   {symbol.apiScope === 'supporting' && <p>This type appears in public signatures. It is not a package entry point.</p>}
-  <ApiEntry symbol={symbol} index={index} port={model.port} alternativesFor={alternativesFor} heading linkRows={false} sourceUrl={(entry) => sourceUrl(model, entry)} />
+  <ApiEntry symbol={symbol} index={index} port={model.port} alternativesFor={alternativesFor} heading linkRows={false} sourceUrl={(entry) => sourceUrl(model, entry)}
+    alternate={(entry) => alternateDocs(model, entry, version)} />
   <ApiTmuxSections sections={tmuxSections} />
   {table && <div class="api-field-table mt-8">
     <h2 class="api-section-heading text-lg font-semibold" id={table.id}>{table.label}<span class="api-section-count">{table.rows.length}</span><a class="api-heading-link" href={`#${table.id}`} aria-label={`Link to ${table.label}`}>#</a></h2>
diff --git a/site/src/components/docs/DocumentationContext.astro b/site/src/components/docs/DocumentationContext.astro
index a420fd64e..31f63979e 100644
--- a/site/src/components/docs/DocumentationContext.astro
+++ b/site/src/components/docs/DocumentationContext.astro
@@ -79,7 +79,11 @@ const tmuxVersions = !port ? TMUX_VERSIONS.map((entry) => ({
   .documentation-context :global(.doc-picker:not([data-enhanced]) > .doc-picker-panel) { width: min(var(--picker-width), calc(100% - 1rem)); }
   .documentation-context :global(.surface-picker > summary) { border-color: transparent; background: transparent; padding-inline-start: calc(var(--site-gutter) - .75rem - 1px); }
   .documentation-context :global(.surface-picker > summary:hover), .documentation-context :global(.surface-picker[open] > summary) { border-color: var(--color-edge); background: var(--background-color); }
-  .documentation-context :global(.surface-current strong), .documentation-context :global(.surface-current small) { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .documentation-context :global(.surface-current small) { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  /* The name gives way before its badge: a long status such as "unreleased" stays readable beside a shortened name. */
+  .documentation-context :global(.surface-current strong) { display: flex; align-items: center; min-width: 0; white-space: nowrap; }
+  .documentation-context :global(.surface-current .surface-label) { min-width: 0; overflow: hidden; text-overflow: ellipsis; }
+  .documentation-context :global(.surface-current__badge) { flex: none; }
   @media (max-width: 40rem) {
     .documentation-context-surface { flex: 1 1 0; padding: .25rem; }
     .documentation-context-selectors { flex: none; gap: .2rem; padding: .25rem; }
diff --git a/site/src/components/icons/RegistryIcon.astro b/site/src/components/icons/RegistryIcon.astro
index 14a12176a..ea878541a 100644
--- a/site/src/components/icons/RegistryIcon.astro
+++ b/site/src/components/icons/RegistryIcon.astro
@@ -12,11 +12,12 @@
  *
  * PyPI uses its official full-colour blocks at 24px; its monochrome paths
  * merge at text size. Other path data comes from simple-icons (CC0-1.0), except
- * the javadoc mark, a generic book, the Hex mark, a hexagon around an H, and
- * the HexDocs mark, an open book: all drawn for this site, because none of
- * those hosts publishes a vector mark. The marks themselves belong to their
- * projects and are used here to identify the destination, which is what the
- * links are for.
+ * the javadoc mark, a generic book, the Hex mark, a hexagon around an H, the
+ * HexDocs mark, an open book, the CPAN mark, a letter C around a package, and
+ * the POD mark, a page of text under a heading: all drawn for this site,
+ * because none of those hosts publishes a vector mark. The marks themselves
+ * belong to their projects and are used here to identify the destination,
+ * which is what the links are for.
  */
 import { withRoot } from '../../lib/site-root'
 
@@ -27,6 +28,9 @@ interface Props {
 }
 
 export type IconName = 'github' | 'pypi' | 'npm' | 'crates' | 'go' | 'maven' | 'nuget' | 'swift' | 'rubygems' | 'luarocks' | 'powershell' | 'docsrs' | 'javadoc' | 'docc' | 'packages' | 'hex' | 'hexdocs'
+  | 'cpan'
+  | 'pod'
+  | 'raku-land'
 
 const ICONS: Record<Exclude<IconName, 'pypi' | 'powershell'>, { label: string; path: string }> = {
   github: {
@@ -88,6 +92,21 @@ const ICONS: Record<Exclude<IconName, 'pypi' | 'powershell'>, { label: string; p
     label: 'HexDocs',
     path: 'M2 5.2c2.9-1.2 6.6-1.1 9 .8v12.6c-2.4-1.5-6-1.7-9-.6zM22 5.2c-2.9-1.2-6.6-1.1-9 .8v12.6c2.4-1.5 6-1.7 9-.6z',
   },
+  // A letter C with a package at its centre, for the archive the distributions ship in.
+  cpan: {
+    label: 'MetaCPAN',
+    path: 'M20.04 5.25A10.5 10.5 0 1 0 20.04 18.75L16.98 16.18A6.5 6.5 0 1 1 16.98 7.82zM10 10h4v4h-4z',
+  },
+  // A page of text under a double rule, for the POD a module ships: the CPAN mark belongs to the distribution page.
+  pod: {
+    label: 'MetaCPAN POD',
+    path: 'M7 2h10a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2zM8 5.5v1.5h8V5.5zM8 8.5V10h8V8.5zM8 13v1.5h8V13zM8 16.5V18h5v-1.5z',
+  },
+  // A square frame around an R, drawn for this site: Raku Land publishes no vector mark of its own.
+  'raku-land': {
+    label: 'Raku Land',
+    path: 'M5 2h14a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H5a3 3 0 0 1-3-3V5a3 3 0 0 1 3-3zM4.2 4.2v15.6h15.6V4.2zM8.6 7.4h3.9c1.7 0 2.9 1 2.9 2.5 0 1.1-.6 1.9-1.6 2.3l2 3.9h-1.8l-1.8-3.5h-1.9v3.5H8.6zM10.2 8.9v2.1h2.2c.8 0 1.3-.4 1.3-1.05S13.2 8.9 12.4 8.9z',
+  },
   luarocks: {
     label: 'LuaRocks',
     path: 'M7 1h10l6 7-2 11-9 4-9-4L1 8zm1.4 4L5.2 9l1.4 7.2L12 19l5.4-2.8L18.8 9l-3.2-4zM9 7h6l1.5 3.5-2 4.5h-5l-2-4.5z',
@@ -127,6 +146,9 @@ const { label, path } = icon === 'powershell' ? { label: 'PowerShell Gallery', p
   .registry-icon[data-icon='swift'] { --icon-brand: #f05138; --icon-brand-dark: #ff7a5e; }
   .registry-icon[data-icon='rubygems'] { --icon-brand: #e9573f; --icon-brand-dark: #ff7662; }
   .registry-icon[data-icon='luarocks'] { --icon-brand: #2c3e86; --icon-brand-dark: #8095e8; }
+  .registry-icon[data-icon='cpan'] { --icon-brand: #39457e; --icon-brand-dark: #9aa7e8; }
+  .registry-icon[data-icon='pod'] { --icon-brand: #39457e; --icon-brand-dark: #9aa7e8; }
+  .registry-icon[data-icon='raku-land'] { --icon-brand: #0000fb; --icon-brand-dark: #8c8cfd; }
   .registry-icon[data-icon='docsrs'] { --icon-brand: #000000; --icon-brand-dark: #ffffff; }
   .registry-icon[data-icon='javadoc'] { --icon-brand: #b3261e; --icon-brand-dark: #ff8a80; }
   .registry-icon[data-icon='docc'] { --icon-brand: #f05138; --icon-brand-dark: #ff7a5e; }
diff --git a/site/src/content/docs/meta/linking.md b/site/src/content/docs/meta/linking.md
index 9217e4738..1b74c6a89 100644
--- a/site/src/content/docs/meta/linking.md
+++ b/site/src/content/docs/meta/linking.md
@@ -23,7 +23,7 @@ links to select a language, version or preview.
 <!-- port:root,py,ruby,julia,ts,rs,go,java,csharp,cxx,swift -->
 | [llms-full.txt](/llms-full.txt) | Fetch guides and MCP contracts together as Markdown. API references are linked separately. |
 <!-- /port -->
-<!-- port:lua,powershell,erlang,elixir,haskell,lisp,ocaml,perl -->
+<!-- port:lua,powershell,erlang,elixir,haskell,lisp,ocaml,perl,raku -->
 | [llms-full.txt](/llms-full.txt) | Fetch the guides together as Markdown. API references are linked separately. |
 <!-- /port -->
 | [docs.json](/docs.json) | Discover page titles, URLs, descriptions, headings and Markdown URLs in a structured manifest. |
diff --git a/site/src/content/docs/ports/erlang/examples/index.md b/site/src/content/docs/ports/erlang/examples/index.md
index 7df2ac52b..b040b1c11 100644
--- a/site/src/content/docs/ports/erlang/examples/index.md
+++ b/site/src/content/docs/ports/erlang/examples/index.md
@@ -15,28 +15,28 @@ adapting a program to an existing server.
 
 | Program | What it demonstrates | Guide |
 | --- | --- | --- |
-| [inspect_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/inspect_demo.erl) | Inspect an existing tmux socket without changing its sessions. | [Installation](../guides/installation/) |
-| [readme_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/readme_demo.erl) | Create a workspace, query its graph and preserve captured values. | [Getting started](../guides/getting-started/) |
-| [linked_graph.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/linked_graph.erl) | Distinguish physical windows from their session memberships. | [Object graph](../concepts/object-graph/) |
-| [filter_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/filter_demo.erl) | Validate portable JSON and filter captured rows without tmux I/O. | [Selections and queries](../concepts/queries/) |
-| [control_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/control_demo.erl) | Attach explicitly, inspect captured values and prove detachment. | [Control connections](../topics/control/) |
-| [native_consumer.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/native_consumer.erl) | Construct native values and exercise a borrowed endpoint through public APIs. | Installed-consumer check |
+| [inspect_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/inspect_demo.erl) | Inspect an existing tmux socket without changing its sessions. | [Installation](../guides/installation/) |
+| [readme_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/readme_demo.erl) | Create a workspace, query its graph and preserve captured values. | [Getting started](../guides/getting-started/) |
+| [linked_graph.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/linked_graph.erl) | Distinguish physical windows from their session memberships. | [Object graph](../concepts/object-graph/) |
+| [filter_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/filter_demo.erl) | Validate portable JSON and filter captured rows without tmux I/O. | [Selections and queries](../concepts/queries/) |
+| [control_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/control_demo.erl) | Attach explicitly, inspect captured values and prove detachment. | [Control connections](../topics/control/) |
+| [native_consumer.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/native_consumer.erl) | Construct native values and exercise a borrowed endpoint through public APIs. | Installed-consumer check |
 
 ## Run, send and capture
 
 | Program | What it demonstrates | Guide |
 | --- | --- | --- |
-| [job_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/job_demo.erl) | Capture a job that acknowledges terminal parsing before it exits. | [Owned operations](../guides/operations/) |
-| [pipe_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/pipe_demo.erl) | Save terminal bytes after a consumer acknowledgement. | [Pipe pane output](../guides/piping/) |
-| [pane_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/pane_demo.erl) | Isolate a running pane, then join it back without respawning. | [Panes](../guides/panes/) |
-| [command_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/command_demo.erl) | Build captured-target commands, then execute and inspect them. | [Commands](../guides/commands/) |
+| [job_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/job_demo.erl) | Capture a job that acknowledges terminal parsing before it exits. | [Owned operations](../guides/operations/) |
+| [pipe_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/pipe_demo.erl) | Save terminal bytes after a consumer acknowledgement. | [Pipe pane output](../guides/piping/) |
+| [pane_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/pane_demo.erl) | Isolate a running pane, then join it back without respawning. | [Panes](../guides/panes/) |
+| [command_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/command_demo.erl) | Build captured-target commands, then execute and inspect them. | [Commands](../guides/commands/) |
 
 ## Options, hooks, keys and buffers
 
 | Program | What it demonstrates | Guide |
 | --- | --- | --- |
-| [options_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/options_demo.erl) | Use local options to mark workspace ownership without inheritance. | [Options](../guides/options/) |
-| [config_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/config_demo.erl) | Apply session configuration and wait for its explicit signal. | [Configuration](../guides/configuration/) |
-| [hook_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/hook_demo.erl) | Acknowledge a registered split hook before reading its effect. | [Hooks](../guides/hooks/) |
-| [key_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/key_demo.erl) | Install and remove an application-owned key table. | [Keys](../guides/keys/) |
-| [buffer_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/f1a2e66c0fa15d1e8d4efa2725a159121815293b/examples/buffer_demo.erl) | Store a binary artifact without terminal or text conversion. | [Buffers](../guides/buffers/) |
+| [options_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/options_demo.erl) | Use local options to mark workspace ownership without inheritance. | [Options](../guides/options/) |
+| [config_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/config_demo.erl) | Apply session configuration and wait for its explicit signal. | [Configuration](../guides/configuration/) |
+| [hook_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/hook_demo.erl) | Acknowledge a registered split hook before reading its effect. | [Hooks](../guides/hooks/) |
+| [key_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/key_demo.erl) | Install and remove an application-owned key table. | [Keys](../guides/keys/) |
+| [buffer_demo.erl](https://github.com/libtmux/libtmux-erlang/blob/539c7297ceae65a1cf683e0836eae0a1ccd34d64/examples/buffer_demo.erl) | Store a binary artifact without terminal or text conversion. | [Buffers](../guides/buffers/) |
diff --git a/site/src/content/docs/ports/perl/core/index.md b/site/src/content/docs/ports/perl/core/index.md
index de8ac2b35..8ba5efa35 100644
--- a/site/src/content/docs/ports/perl/core/index.md
+++ b/site/src/content/docs/ports/perl/core/index.md
@@ -23,4 +23,6 @@ loop. Its [transport reference](../reference/libtmux-async-transport/) explains
 admission, cancellation, and cleanup. Linux x86_64 LP64 is qualified; other
 platforms and ABIs remain unsupported.
 
-The distributions are available from source and have no CPAN release.
+The LibTmux, LibTmux-Async, and LibTmux-Workspace distributions are on CPAN.
+The [installation guide](../guides/) lists the `cpm` command for each, and a
+source checkout remains available for development.
diff --git a/site/src/content/docs/ports/perl/workspace/index.md b/site/src/content/docs/ports/perl/workspace/index.md
index bca537b2e..cbb2515e6 100644
--- a/site/src/content/docs/ports/perl/workspace/index.md
+++ b/site/src/content/docs/ports/perl/workspace/index.md
@@ -15,7 +15,8 @@ APIs. Its `libtmux-workspace` command validates, plans, and loads the
 [libtmux.workspace/v1 JSON format](./source-guide/). Planning performs no tmux I/O. Loading
 creates sessions, windows, and panes, with explicit conflict and repeat policies.
 
-Install core first, then workspace from the same source checkout. These
-packages are not published to CPAN. The [workspace guide](./source-guide/)
-contains the configuration contract and installed CLI commands. The
+Install it from CPAN with `cpm install --global LibTmux::Workspace`; the
+installer resolves the core distribution it depends on. The
+[workspace guide](./source-guide/) contains the configuration contract and
+installed CLI commands. The
 [API reference](./reference/) documents the public loader and report errors.
diff --git a/site/src/content/docs/ports/raku/core/index.md b/site/src/content/docs/ports/raku/core/index.md
new file mode 100644
index 000000000..9185a5fa2
--- /dev/null
+++ b/site/src/content/docs/ports/raku/core/index.md
@@ -0,0 +1,28 @@
+---
+port: raku
+route: core
+title: tmux client library for Raku
+description: "tmux client library for Raku. Control tmux, connect to and create servers, navigate sessions, windows, and panes, send keys, watch for changes via control mode, capture pane contents"
+cards:
+  - label: Getting started
+    href: ../guides/getting-started/
+    body: Install LibTmux, create and split panes, and find them through typed snapshots.
+  - label: Examples
+    href: ../examples/programs/
+    body: Run six complete programs against private tmux servers and compare their output.
+  - label: tmux compatibility
+    href: ../topics/compatibility/
+    body: Check the supported tmux releases and how the library handles newer ones.
+  - label: API reference
+    href: ../reference/
+    body: Native signatures, RakuDoc and links for every public module, class and method.
+---
+
+LibTmux gives Raku programs typed snapshots of a tmux server, ordinary
+predicates over them, and explicit commands that change tmux. Reading a
+snapshot makes no further tmux calls; an operation through a reference does.
+
+The LibTmux distribution from the zef:libtmux authority is published on Raku Land. Its API
+is experimental and may change between `0.x` releases. CI qualifies Rakudo
+2026.09 on Linux with tmux 3.3a and 3.8; other platforms and compiler versions
+are unverified. The library has no workspace manager or MCP server.
diff --git a/site/src/data/api-destination-evidence.json b/site/src/data/api-destination-evidence.json
index a3c06afad..d8c35b447 100644
--- a/site/src/data/api-destination-evidence.json
+++ b/site/src/data/api-destination-evidence.json
@@ -1,6 +1,6 @@
 {
   "schema": 2,
-  "checkedAt": "2026-11-12",
+  "checkedAt": "2026-11-14",
   "inventories": [
     {"name":"python","source":"https://docs.python.org/3/objects.inv","kind":"objects.inv","entries":16493,"digest":"9b186d22c55bd3056145d7009198a34a0274d7e4","ok":true,"missing":0,"checkedAt":"2026-10-25"},
     {"name":"julia","source":"https://docs.julialang.org/en/v1/objects.inv","kind":"objects.inv","entries":2545,"digest":"94ff52276c38e7feea3d68234092a72496935b01","ok":true,"missing":0,"checkedAt":"2026-10-25"},
@@ -720,11 +720,17 @@
     {"url":"https://luals.github.io/wiki/annotations/#class","host":"luals.github.io","status":200,"via":"html","title":"Lua Language Server | Wiki","heading":"@class","ok":true,"fragment":"found","terminal":[{"key":"authored:Lua class annotations","symbol":"Lua class annotations","at":"review"},{"key":"authored:Lua class inheritance","symbol":"Lua class inheritance","at":"review"}],"checkedAt":"2026-10-25","names":["glossary lua class","glossary lua inherited"],"sources":["authored"]},
     {"url":"https://luals.github.io/wiki/annotations/#documenting-types","host":"luals.github.io","status":200,"via":"html","title":"Lua Language Server | Wiki","ok":true,"fragment":"found","terminal":[{"symbol":"any","at":"section","reason":"the wiki lists the recognized types in one section"}],"checkedAt":"2026-10-25","names":["lua:any"],"sources":["builtin","prose"]},
     {"url":"https://luals.github.io/wiki/annotations/#overload","host":"luals.github.io","status":200,"via":"html","title":"Lua Language Server | Wiki","heading":"@overload","ok":true,"fragment":"found","terminal":[{"key":"authored:Lua overload annotations","symbol":"Lua overload annotations","at":"review"}],"checkedAt":"2026-10-25","names":["glossary lua overload"],"sources":["authored"]},
+    {"url":"https://metacpan.org/dist/LibTmux","host":"metacpan.org","status":200,"via":"html","title":"LibTmux-0.003 - Captured tmux graph queries and explicit process execution - metacpan.org","identity":{"via":"page","declared":"page","kind":"other","path":[]},"heading":"LibTmux-0.003 - Captured tmux graph queries and explicit process execution - metacpan.org","ok":true,"terminal":[{"key":"authored:CPAN","symbol":"CPAN","at":"review"},{"key":"authored:LibTmux","symbol":"LibTmux","at":"review"},{"key":"doc-link:CPAN distribution","symbol":"CPAN distribution","at":"review"}],"checkedAt":"2026-11-14","names":["perl:CPAN distribution","site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/content/docs/_staged/perl/guides/installation/index.md","site/src/data/port-guides/perl.json"],"sources":["authored","doc-link"]},
+    {"url":"https://metacpan.org/dist/LibTmux-Async","host":"metacpan.org","status":200,"via":"html","title":"LibTmux-Async-0.003 - Optional Future-based libtmux execution - metacpan.org","identity":{"via":"page","declared":"page","kind":"other","path":[]},"heading":"LibTmux-Async-0.003 - Optional Future-based libtmux execution - metacpan.org","ok":true,"terminal":[{"key":"authored:CPAN","symbol":"CPAN","at":"review"},{"key":"authored:LibTmux-Async","symbol":"LibTmux-Async","at":"review"},{"key":"doc-link:CPAN distribution","symbol":"CPAN distribution","at":"review"}],"checkedAt":"2026-11-14","names":["perl:CPAN distribution","site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/content/docs/_staged/perl/guides/installation/index.md","site/src/data/port-guides/perl.json"],"sources":["authored","doc-link"]},
+    {"url":"https://metacpan.org/dist/LibTmux-Workspace","host":"metacpan.org","status":200,"via":"html","title":"LibTmux-Workspace-0.003 - Versioned workspace configuration for tmux - metacpan.org","identity":{"via":"page","declared":"page","kind":"other","path":[]},"heading":"LibTmux-Workspace-0.003 - Versioned workspace configuration for tmux - metacpan.org","ok":true,"terminal":[{"key":"authored:CPAN","symbol":"CPAN","at":"review"},{"key":"authored:LibTmux-Workspace","symbol":"LibTmux-Workspace","at":"review"},{"key":"doc-link:CPAN distribution","symbol":"CPAN distribution","at":"review"}],"checkedAt":"2026-11-14","names":["perl:CPAN distribution","site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/content/docs/_staged/perl/guides/installation/index.md","site/src/data/port-guides/perl.json"],"sources":["authored","doc-link"]},
     {"url":"https://metacpan.org/pod/Future","host":"metacpan.org","status":200,"via":"html","title":"Future - represent an operation awaiting completion - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["Future"]},"heading":"Future","ok":true,"terminal":[{"key":"doc-link:Future","symbol":"Future","at":"identity"}],"checkedAt":"2026-11-07","names":["perl:Future"],"sources":["doc-link"]},
     {"url":"https://metacpan.org/pod/IO::Async","host":"metacpan.org","status":200,"via":"html","title":"IO::Async - Asynchronous event-driven programming - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["IO","Async"]},"heading":"IO.Async","ok":true,"terminal":[{"key":"doc-link:IO::Async","symbol":"IO::Async","at":"identity"}],"checkedAt":"2026-11-07","names":["perl:IO::Async"],"sources":["doc-link"]},
     {"url":"https://metacpan.org/pod/IO::Async::Loop","host":"metacpan.org","status":200,"via":"html","title":"IO::Async::Loop - core loop of the IO::Async framework - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["IO","Async","Loop"]},"heading":"IO.Async.Loop","ok":true,"terminal":[{"key":"doc-link:IO::Async::Loop","symbol":"IO::Async::Loop","at":"identity"}],"checkedAt":"2026-11-07","names":["perl:IO::Async::Loop"],"sources":["doc-link"]},
     {"url":"https://metacpan.org/pod/IO::Async::Loop::Ppoll","host":"metacpan.org","status":200,"via":"html","title":"IO::Async::Loop::Ppoll - use IO::Async with ppoll(2) - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["IO","Async","Loop","Ppoll"]},"heading":"IO.Async.Loop.Ppoll","ok":true,"terminal":[{"key":"authored:`IO::Async::Loop::Ppoll`","symbol":"`IO::Async::Loop::Ppoll`","at":"identity"},{"key":"doc-link:IO::Async::Loop::Ppoll","symbol":"IO::Async::Loop::Ppoll","at":"identity"}],"checkedAt":"2026-11-08","names":["perl:IO::Async::Loop::Ppoll","site/src/content/docs/_staged/perl/guides/async/index.md","site/src/data/port-guides/perl.json"],"sources":["authored","doc-link"]},
     {"url":"https://metacpan.org/pod/IO::Ppoll","host":"metacpan.org","status":200,"via":"html","title":"IO::Ppoll - Object interface to the ppoll() system call - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["IO","Ppoll"]},"heading":"IO.Ppoll","ok":true,"terminal":[{"key":"doc-link:IO::Ppoll","symbol":"IO::Ppoll","at":"identity"}],"checkedAt":"2026-11-08","names":["perl:IO::Ppoll"],"sources":["doc-link"]},
+    {"url":"https://metacpan.org/pod/LibTmux","host":"metacpan.org","status":200,"via":"package","title":"LibTmux","heading":"LibTmux","ok":true,"terminal":[{"key":"authored:POD","symbol":"POD","at":"review"}],"checkedAt":"2026-11-14","names":["site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/data/port-guides/perl.json"],"sources":["authored"]},
+    {"url":"https://metacpan.org/pod/LibTmux::Async","host":"metacpan.org","status":200,"via":"package","title":"LibTmux::Async","heading":"LibTmux::Async","ok":true,"terminal":[{"key":"authored:POD","symbol":"POD","at":"review"}],"checkedAt":"2026-11-14","names":["site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/data/port-guides/perl.json"],"sources":["authored"]},
+    {"url":"https://metacpan.org/pod/LibTmux::Workspace","host":"metacpan.org","status":200,"via":"package","title":"LibTmux::Workspace","heading":"LibTmux::Workspace","ok":true,"terminal":[{"key":"authored:POD","symbol":"POD","at":"review"}],"checkedAt":"2026-11-14","names":["site/src/content/docs/_staged/perl/guides/getting-started/index.md","site/src/data/port-guides/perl.json"],"sources":["authored"]},
     {"url":"https://metacpan.org/pod/MIME::Base64","host":"metacpan.org","status":200,"via":"html","title":"MIME::Base64 - Encoding and decoding of base64 strings - metacpan.org","identity":{"via":"pod","declared":"module","kind":"module","path":["MIME","Base64"]},"heading":"MIME.Base64","ok":true,"terminal":[{"key":"doc-link:MIME::Base64","symbol":"MIME::Base64","at":"identity"}],"checkedAt":"2026-11-08","names":["perl:MIME::Base64"],"sources":["doc-link"]},
     {"url":"https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations","host":"modelcontextprotocol.io","status":200,"via":"html","title":"Schema Reference - Model Context Protocol","heading":"ToolAnnotations","ok":true,"fragment":"found","terminal":[{"key":"authored:MCP ToolAnnotations","symbol":"MCP ToolAnnotations","at":"review"}],"checkedAt":"2026-10-25","names":["site/src/lib/api-glossary.ts"],"sources":["authored"]},
     {"url":"https://ocaml.org/docs/libraries-dune","host":"ocaml.org","status":200,"via":"html","title":"Libraries With Dune · OCaml Documentation","heading":"Libraries With Dune","ok":true,"terminal":[{"key":"authored:OCaml libraries with Dune","symbol":"OCaml libraries with Dune","at":"review"}],"checkedAt":"2026-11-08","names":["glossary ocaml package"],"sources":["authored"]},
diff --git a/site/src/data/api-link-review.json b/site/src/data/api-link-review.json
index 4e8897747..10b1e1c46 100644
--- a/site/src/data/api-link-review.json
+++ b/site/src/data/api-link-review.json
@@ -980,6 +980,66 @@
       "url": "https://luals.github.io/wiki/annotations/#overload",
       "heading": "@overload"
     },
+    {
+      "label": "CPAN",
+      "url": "https://metacpan.org/dist/LibTmux",
+      "heading": "LibTmux-0.003 - Captured tmux graph queries and explicit process execution - metacpan.org"
+    },
+    {
+      "label": "CPAN distribution",
+      "url": "https://metacpan.org/dist/LibTmux",
+      "heading": "LibTmux-0.003 - Captured tmux graph queries and explicit process execution - metacpan.org"
+    },
+    {
+      "label": "LibTmux",
+      "url": "https://metacpan.org/dist/LibTmux",
+      "heading": "LibTmux-0.003 - Captured tmux graph queries and explicit process execution - metacpan.org"
+    },
+    {
+      "label": "CPAN",
+      "url": "https://metacpan.org/dist/LibTmux-Async",
+      "heading": "LibTmux-Async-0.003 - Optional Future-based libtmux execution - metacpan.org"
+    },
+    {
+      "label": "CPAN distribution",
+      "url": "https://metacpan.org/dist/LibTmux-Async",
+      "heading": "LibTmux-Async-0.003 - Optional Future-based libtmux execution - metacpan.org"
+    },
+    {
+      "label": "LibTmux-Async",
+      "url": "https://metacpan.org/dist/LibTmux-Async",
+      "heading": "LibTmux-Async-0.003 - Optional Future-based libtmux execution - metacpan.org"
+    },
+    {
+      "label": "CPAN",
+      "url": "https://metacpan.org/dist/LibTmux-Workspace",
+      "heading": "LibTmux-Workspace-0.003 - Versioned workspace configuration for tmux - metacpan.org"
+    },
+    {
+      "label": "CPAN distribution",
+      "url": "https://metacpan.org/dist/LibTmux-Workspace",
+      "heading": "LibTmux-Workspace-0.003 - Versioned workspace configuration for tmux - metacpan.org"
+    },
+    {
+      "label": "LibTmux-Workspace",
+      "url": "https://metacpan.org/dist/LibTmux-Workspace",
+      "heading": "LibTmux-Workspace-0.003 - Versioned workspace configuration for tmux - metacpan.org"
+    },
+    {
+      "label": "POD",
+      "url": "https://metacpan.org/pod/LibTmux",
+      "heading": "LibTmux"
+    },
+    {
+      "label": "POD",
+      "url": "https://metacpan.org/pod/LibTmux::Async",
+      "heading": "LibTmux::Async"
+    },
+    {
+      "label": "POD",
+      "url": "https://metacpan.org/pod/LibTmux::Workspace",
+      "heading": "LibTmux::Workspace"
+    },
     {
       "label": "MCP ToolAnnotations",
       "url": "https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations",
diff --git a/site/src/data/api/erlang.json b/site/src/data/api/erlang.json
index c3c8cce57..fcfed5f2b 100644
--- a/site/src/data/api/erlang.json
+++ b/site/src/data/api/erlang.json
@@ -1 +1 @@
-{"port":"erlang","repo":"libtmux/libtmux-erlang","revision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b","extractor":"@libtmux/api-model@0.0.1 (Erlang EEP-48 and abstract code v3)","nativeProvenance":{"files":[{"path":".tool-versions","sha256":"73a9c039345d63a5316d1818639cabf8f563af4752b3d25168aff80beae90a68"},{"path":"apps/libtmux_erlang/rebar.config","sha256":"7dde37bc878d42712eb562a96f7b2bef0f717d552c1fe115c3224cf7a39c59a2"},{"path":"apps/libtmux_erlang/src/libtmux_erlang.app.src","sha256":"49ec4b3c4d58af70fc014ad893178bc739305489d89678a4636a567caf00c0a5"},{"path":"apps/libtmux_erlang/src/libtmux_erlang_app.erl","sha256":"b649483a5e0bf6cc3a377aa06a381e6afe2b316f0c64590d13dc650520040328"},{"path":"apps/libtmux_erlang/src/tmux_admission.erl","sha256":"78330dddda6ae5854d2e72585523c6664293167d4b25273015494f8877029b4f"},{"path":"apps/libtmux_erlang/src/tmux_args.erl","sha256":"f054894dfd02179f09fe153afacf29dd9e8494ec381abd07ab92b56300ca10cd"},{"path":"apps/libtmux_erlang/src/tmux_buffer.erl","sha256":"c05edba9f3cfde487d699b5ed7e83b8353f0d7419db309a22d8a0f938572f996"},{"path":"apps/libtmux_erlang/src/tmux_buffer_codec.erl","sha256":"872d28160204881f0b11de18ae99704ca17a1e5914819abd3c1c30298427121e"},{"path":"apps/libtmux_erlang/src/tmux_capability.erl","sha256":"1514ac1583f5f870c067585f4509a1304147b2e4527a7026dfdac367c54c72c1"},{"path":"apps/libtmux_erlang/src/tmux_capability_data.erl","sha256":"e5a6f66ded73cb16e53d9f6bbbc0d6066088e58598b8e970b37e6bb3ea142e1e"},{"path":"apps/libtmux_erlang/src/tmux_command.erl","sha256":"4ef3e833cd4beeb62f8dc34994fd4071a0df675c3e2304b3e80fcd6d9579153c"},{"path":"apps/libtmux_erlang/src/tmux_control.erl","sha256":"0a5412aa42a2616a12a07310facd5bd2a669e2753949c3dc4966fac7aaeb0bdf"},{"path":"apps/libtmux_erlang/src/tmux_control_codec.erl","sha256":"a3395198fe0ebba49dc598f0e2503a14f2b00b2ccb36982c90513f851a6a5b48"},{"path":"apps/libtmux_erlang/src/tmux_error.erl","sha256":"ccb10f5a434672a20068759ee1b54ba6c6c503f0f876247aad7125c6b4c5ad82"},{"path":"apps/libtmux_erlang/src/tmux_filter.erl","sha256":"b582961447a700c38d348230a016918cf07cec169ab46d11b4c9a925857a142b"},{"path":"apps/libtmux_erlang/src/tmux_filter_eval.erl","sha256":"5e715cfa4110951771cbd7fe13eb2797a2ff2dd2d38ed5838b500524a3f7fbc2"},{"path":"apps/libtmux_erlang/src/tmux_hook.erl","sha256":"723c166ff42524679066011916463761ad5d4e9ccc6e9c901beb3cca6df53a3d"},{"path":"apps/libtmux_erlang/src/tmux_identity.erl","sha256":"31ab809d3c407e0214f6b952e4e24cc5289f3d4ee305f6fe0b9b1520f4af9d7d"},{"path":"apps/libtmux_erlang/src/tmux_json.erl","sha256":"2dce31dd87dae4e32c314de5c1ddefcee077cfef09a78cbcf6f660748573ddfc"},{"path":"apps/libtmux_erlang/src/tmux_key.erl","sha256":"00c7d3a141d377c115cf2a6d010312aa4c006d34355111ff51424b3c2b2a3e23"},{"path":"apps/libtmux_erlang/src/tmux_log.erl","sha256":"885dcb198a82a0ed13f8c766e63e3953e4e9134f5d4bd2f86e79f0e0de65783a"},{"path":"apps/libtmux_erlang/src/tmux_matcher.erl","sha256":"b599f732e73ad9c7701df6c9c65c9524645c988bb5ba2d0729b9004136d29c16"},{"path":"apps/libtmux_erlang/src/tmux_model.erl","sha256":"519cfeb36fa0ea3df6d742edc87ded1f9d4800fc4fe7c662f2e676e29a4ce0a9"},{"path":"apps/libtmux_erlang/src/tmux_observe.erl","sha256":"4e726b823568a66cdf0f3c34aeb6c0b55651522da9a6263d077a2926cd699da0"},{"path":"apps/libtmux_erlang/src/tmux_operation.erl","sha256":"f5d34e31af1ac17e267bff6529a454d095ff3c7c238d64d6bbb0002e54285c47"},{"path":"apps/libtmux_erlang/src/tmux_option.erl","sha256":"c1872d0d9f74f136d0fbb1a2b28232d4245a197f8fd84d78ae6bf4200fd0088a"},{"path":"apps/libtmux_erlang/src/tmux_option_batch.erl","sha256":"16b90a2b4e8bf168dd3d5bd56bfbb4a561cfd9ff8f43054917ce9500488b195b"},{"path":"apps/libtmux_erlang/src/tmux_option_codec.erl","sha256":"cd3dc1cc2d457cd711247c539f0fc0e3498303180751724ebae77462cede9b6d"},{"path":"apps/libtmux_erlang/src/tmux_option_data.erl","sha256":"8fe72d14d2ec8d6a9aef7ac8a46923f3c70f47f45b5c6fcd0b1754eae8ca0ae4"},{"path":"apps/libtmux_erlang/src/tmux_option_scope.erl","sha256":"7f6227cd1808bf8b27df12fafc3c35c073797efee7a4ed9f89e19bc2b498ed11"},{"path":"apps/libtmux_erlang/src/tmux_owned_server.erl","sha256":"17521c819d7aea427429dc18aafee101544a6f85c0772857d540d1dd887a44f3"},{"path":"apps/libtmux_erlang/src/tmux_pane.erl","sha256":"e71ac56dab19886495cae801a1a83d85123e519de1c10ba8eb4128c8ff33db48"},{"path":"apps/libtmux_erlang/src/tmux_query.erl","sha256":"687cc6d89f68815662d8154ed3326ed69dd5b665c4cc1fec10036022c52cb641"},{"path":"apps/libtmux_erlang/src/tmux_query_plan.erl","sha256":"98299c186428ccc70588cee87b65e89d172045b89d01d0c88996834454238a93"},{"path":"apps/libtmux_erlang/src/tmux_regex.erl","sha256":"c97133a505dfbf7a54b0b59645429a3a512482bec99dfc5cc8da0ef27664af44"},{"path":"apps/libtmux_erlang/src/tmux_registry.erl","sha256":"e0370601b396566bb24323a65e0fc2e6a1930c6298cbd125590009a4855d0740"},{"path":"apps/libtmux_erlang/src/tmux_schema.erl","sha256":"85ebfc0c7f53cf4e7952f9ec440395646d48d9100ad2ea191d9c053759625a65"},{"path":"apps/libtmux_erlang/src/tmux_schema_data.erl","sha256":"4cd255118e2b207d40507fa2a5b91af7555e41134986eff7c58ce2349a96560d"},{"path":"apps/libtmux_erlang/src/tmux_scope.erl","sha256":"02c1624a9618fb24022b13263e6de0ca14ca60e5ff7b773e1ecfdd742b2ea03b"},{"path":"apps/libtmux_erlang/src/tmux_select.erl","sha256":"49f16937a1edf0057364f54718907d48fa2442a6410c38218f984c456874968c"},{"path":"apps/libtmux_erlang/src/tmux_server.erl","sha256":"e54e0940fb9c86985620e0c983538fbcf9e4e06b0c36b925dc7c46c21451d516"},{"path":"apps/libtmux_erlang/src/tmux_session.erl","sha256":"150217b8d739092eded788198c86e0d82d6e7e81453ab8c3423c53ea8d4280d0"},{"path":"apps/libtmux_erlang/src/tmux_snapshot.erl","sha256":"570e30612017e0a80be44fcae0ad5aaf44968588244916efc93516751dc58f81"},{"path":"apps/libtmux_erlang/src/tmux_sup.erl","sha256":"d0769251b68e8118e8cb58d2cd974cbf59e8c72b5713e738d6b82df14cd400ee"},{"path":"apps/libtmux_erlang/src/tmux_target.erl","sha256":"107de5ba111b6ff3641c3e1ba2197b6a66808a654e031b0837ff2befaad67d5d"},{"path":"apps/libtmux_erlang/src/tmux_text_codec.erl","sha256":"22b3823103dd84df3e21d6b9e2362da9f74c062731253fbac0b555868be758db"},{"path":"apps/libtmux_erlang/src/tmux_transport.erl","sha256":"1be3ba6148a39b041720b1123f42fd1d9142993dff39e8b655b24db245f25b82"},{"path":"apps/libtmux_erlang/src/tmux_transport_codec.erl","sha256":"516f5d3d79f31702a7b27b09945e1f5b8b9cfce613ede4ac9edc817f941686df"},{"path":"apps/libtmux_erlang/src/tmux_version.erl","sha256":"c09c120c90ec42a7cc55772b13823e3169259c68f2330537f1e5cb19e087d283"},{"path":"apps/libtmux_erlang/src/tmux_window.erl","sha256":"8fd8325549b1756f76c3fceb36ccfcf15068ec9c0cfa6a290da8ae3067817a4e"},{"path":"apps/libtmux_erlang/src/tmux_window_link.erl","sha256":"3584235656fc15976074e964f5ab2042e7dc83ed0fa3748a28059da32dd7550c"},{"path":"apps/libtmux_erlang/test/tmux_admission_tests.erl","sha256":"90cd16fd73aaaa9ac32ac1ac2b6ccf16d879b5dee88950d42d44455ac33c92a3"},{"path":"apps/libtmux_erlang/test/tmux_buffer_tests.erl","sha256":"0f117487e30b8edc908393ed85f3837d92c3f4309b0f5e7233c3926822bc8fee"},{"path":"apps/libtmux_erlang/test/tmux_capability_tests.erl","sha256":"7062a4401ae2f6d42389780c200957d85613eb635721c294bd8916d851f4bbec"},{"path":"apps/libtmux_erlang/test/tmux_command_tests.erl","sha256":"d0c8e817342d2d2000a097ef248557f3f22c02b149ac068d6da6faf2719f8dfe"},{"path":"apps/libtmux_erlang/test/tmux_domain_tests.erl","sha256":"8df9b7ab8fcf08838cb83bf814e610a8d2fe042abb8c5a7861700d5243b8cc9f"},{"path":"apps/libtmux_erlang/test/tmux_error_tests.erl","sha256":"9561f706fe80150aac64481762a7be1ecd28f26d7b643cf194774691a1eda6e2"},{"path":"apps/libtmux_erlang/test/tmux_filter_fixture_tests.erl","sha256":"2042d790c9a8db07d0260aeb18a1658f1715299a7493d80c95f9ab6667f60f9c"},{"path":"apps/libtmux_erlang/test/tmux_filter_tests.erl","sha256":"297207998c206b10f71799cb9b642fb435b397e8e076f9c5780f5bae4bc2d82e"},{"path":"apps/libtmux_erlang/test/tmux_hook_tests.erl","sha256":"4f9bbdc801ab3d6e14609be8c0f2477bc00d530d9c829b719a8c98a7e3160482"},{"path":"apps/libtmux_erlang/test/tmux_identity_tests.erl","sha256":"fcf254ed09fc1111b65eb4a5dab2304ee013d8eae937cf590b496c3955453945"},{"path":"apps/libtmux_erlang/test/tmux_json_tests.erl","sha256":"55d60e58bd058a1882c1288880cca60596397702594791a7f4907f6bccdd6408"},{"path":"apps/libtmux_erlang/test/tmux_key_tests.erl","sha256":"d39af985776d7ed68e4b39f535b0513f2cda3b95d27ee7f438c64d7490e5f8f8"},{"path":"apps/libtmux_erlang/test/tmux_model_tests.erl","sha256":"ed7b34128ff3c55020a8b430814cd21d7fbd0af49d645d1caf640c9b12a1bde5"},{"path":"apps/libtmux_erlang/test/tmux_option_tests.erl","sha256":"35a8b9a53fe2545095255c04ef0e5d92e21ff09405e6204a73b5bbbbdb25bc07"},{"path":"apps/libtmux_erlang/test/tmux_query_tests.erl","sha256":"3f6a7b2d3dfbcb252b62e2559e2318c976541b763e507ddbf57133582e121cb9"},{"path":"apps/libtmux_erlang/test/tmux_regex_tests.erl","sha256":"53f60668b1c3cf9449ab59b5576e5d367902f374aa6d5a99e50dfa5d0c96a05c"},{"path":"apps/libtmux_erlang/test/tmux_registry_tests.erl","sha256":"1564e63d63be02e2ddc13e58a67a003eb77e3129b4f6d6585d6cb2ef26d8fbc4"},{"path":"apps/libtmux_erlang/test/tmux_scope_tests.erl","sha256":"575a142cc074ffcd51784bfba68bd81b8ab1fb53684e2c47fa912cbf9ae38f19"},{"path":"apps/libtmux_erlang/test/tmux_select_tests.erl","sha256":"130475107a7ade6e18b98987ae222ff4ea12ee9bdb40cf90fd40d37b13292f74"},{"path":"apps/libtmux_erlang/test/tmux_snapshot_tests.erl","sha256":"641dd3e523efdd7a313d5bc8109d13419bedc50f1565a2abbdb4226594a51f60"},{"path":"apps/libtmux_erlang/test/tmux_text_codec_tests.erl","sha256":"fd089f5e50f509390051325c009eeb9abc3aca4a5c046c3562d64061f2c77bd0"},{"path":"apps/libtmux_erlang/test/tmux_transport_codec_tests.erl","sha256":"8769931bdc39f25e927ead06b17b985d192be54610b799ced428d4fab5d351cf"},{"path":"apps/libtmux_erlang/test/tmux_version_tests.erl","sha256":"3867637a0194ef1eee541ad311d3b296436c0220e2323b504b17243a8a588bd1"},{"path":"examples/buffer_demo.erl","sha256":"d4579d644f0d68f5b864036351ad538c7b18f73469d33fa933da248b72028f50"},{"path":"examples/command_demo.erl","sha256":"c9af9f446d73710ade39ee59a29494a9df5be076172a7efa977bc35034a33622"},{"path":"examples/config_demo.erl","sha256":"0d861a00b4f1025976a1c10e1e4873d08cedcf5f622d1d307420672f4caca3e4"},{"path":"examples/control_demo.erl","sha256":"3e407160772d5677ffb6983405bcf032d728e65e3c6eec9566445c41b2a49d7b"},{"path":"examples/filter_demo.erl","sha256":"9b3467b20497d568c0832685c790fcd0909133a15d5814282ccf55765771d321"},{"path":"examples/hook_demo.erl","sha256":"5c6c777bc6a2ab716a00bef55f44b4cf7fe43ad29ad31b55ea092acdeef49087"},{"path":"examples/inspect_demo.erl","sha256":"a87e20080863153c687682f7c21961dd50edd853254dac38f8c09a1b34f03bbd"},{"path":"examples/job_demo.erl","sha256":"8ddbd70130f47ae022d2224646b132e18aa5178b50aa6965b33612230ddf3bf5"},{"path":"examples/key_demo.erl","sha256":"572bb44ae0bca5354d9080993d6010d97caa25dcaaad89417912f4ddcca975e4"},{"path":"examples/linked_graph.erl","sha256":"d6d5f7b51e76e2023c6f33a1547ff71534f6107d705db20d2012122f552c6bf0"},{"path":"examples/native_consumer.erl","sha256":"fe3a5943ada5885c09918b3693510de612437ef6b8bd3b431674c846ae648eea"},{"path":"examples/options_demo.erl","sha256":"37a5a00ae52c25b5eef4ff079b6b5fe8155f54be85488d456ba1399dcddec468"},{"path":"examples/pane_demo.erl","sha256":"e103746aebc97ed5c939e384c935f2bf7830c0e0efa0c269fc70d5dec7b6f300"},{"path":"examples/pipe_demo.erl","sha256":"a5ea3562db13830139f6ffcf95b4b0ef0fb5dee7dcb408335aaad3ac80519e6d"},{"path":"examples/readme_demo.erl","sha256":"1ff24e66b6ac576c63eb2fc481aeeb17ab641608ec4ac56c09f9266e34fcf850"},{"path":"property/prop_tmux_filter.erl","sha256":"1a918ae522b6ae675c3ec2c42ffbb87bfd8cb30bb770ae9ac5f7bf6740b7713e"},{"path":"property/prop_tmux_graph.erl","sha256":"2fe1dfd9e870a5e98ce6a7e4c89a1a33b72d0661dc68860a6d6be83470e17fee"},{"path":"rebar.config","sha256":"7d9c212a4049a2b7f7eae53b2647aec056637f987916835f9b770a7e7e179ef9"},{"path":"rebar.lock","sha256":"11147eb50b093a61fe80253dae762d703387f23054d00907217c4ab3dc2d6b8c"},{"path":"test/consumers/model_types_bad.erl","sha256":"643fe7c662cc031de656149da55ec3c038541a7a1d3ece01ed7b2ca21bc5d68a"},{"path":"test/consumers/model_types_ok.erl","sha256":"fcababe54e4626a8827c319025bc801bcac51457489281d67b02a31edaebf763"},{"path":"test/tmux_buffer_SUITE.erl","sha256":"605251515daff77735e714ac9bd42abdb41695c650236aa3ee1d1d15e77ebbd0"},{"path":"test/tmux_channel_SUITE.erl","sha256":"0c72df0e5291895ee491fc9b6148100bd19c993546f932db35da4240d4f29a34"},{"path":"test/tmux_command_SUITE.erl","sha256":"7d8bc30cff9cb9168885be97a9929090d94314871d2cba6123a327dfe30c464e"},{"path":"test/tmux_control_SUITE.erl","sha256":"787e82c6ab419ceb69d7e75146b1750bf0d8425281b30e541f3865184e352a2f"},{"path":"test/tmux_control_codec_SUITE.erl","sha256":"3244294cd87b33384cadfb2e53ff501aecabb571388e99faf9cbc057158558ce"},{"path":"test/tmux_control_codec_tests.erl","sha256":"6730a09af09dbd5ebcd5e4cb8dd8abafc0c339d7cf14b8f79926a755b95c3705"},{"path":"test/tmux_diagnostics_SUITE.erl","sha256":"72aa812052d70b5af8b44777e0d39dca8f94f43faa3fd1c78c981157d4596246"},{"path":"test/tmux_docs_SUITE.erl","sha256":"fe2e757d2b3496eeb9928ab6fbea00434b5b9bd00bec199730162b14400cf589"},{"path":"test/tmux_domain_SUITE.erl","sha256":"53bf4ec2c1e4ebdbdb11f3cc3f4e235140cb3aa6e9859bc7a79c3ea4b7c30fa7"},{"path":"test/tmux_fixture_SUITE.erl","sha256":"2a7ad27ad63f1892f347fb3b272231a9ed3603f8025527931f6f98024b469e73"},{"path":"test/tmux_hook_SUITE.erl","sha256":"c020bd17251344e15d823e05e0a4ec8be4e05c6b6d3582af2aa659ff08577ef6"},{"path":"test/tmux_key_SUITE.erl","sha256":"3b5d0da672633a7470446008b79741900df9f88d5c12e21559445f2f1f1b2412"},{"path":"test/tmux_option_SUITE.erl","sha256":"88a323f26b52025092e31255f2ab944859cadd45e74ff7fd90cd6d76da0e6583"},{"path":"test/tmux_owned_server_SUITE.erl","sha256":"de43f1cfecf8c20f349a9fcaae0b02fd0559a7ab3f8621caf6f4a0cf40fa0980"},{"path":"test/tmux_pipe_SUITE.erl","sha256":"cfb3cdd298f43dc66afb306f6ac1f5f692968958a959fa8b7bbb2beaaa602b46"},{"path":"test/tmux_query_SUITE.erl","sha256":"63e71283c8aadd680c6fb006c7f9177c66b0c05b258b3849d20ea9e05699da06"},{"path":"test/tmux_server_SUITE.erl","sha256":"af9bdd800ddf33a37d4d48d5b4329f1f90dd8ba93797cfe4beb04e1587244de4"},{"path":"test/tmux_test_fixture.erl","sha256":"48b64d04a7fa2c0c4848f5203c76bc11daa98ddf3d5e1f7cc4ac5a3793ca8d00"},{"path":"test/tmux_topology_SUITE.erl","sha256":"3e5fd3cde6709593e169a93bc1ee684d3e460788400b514439009da3e58397bf"},{"path":"test/tmux_transport_SUITE.erl","sha256":"17ca53bf22a720e3b4b57ee9be9a9e8d2517abd3659b2c79c4b81d92a1eaf01c"}],"exporter":{"name":"Erlang EEP-48 and abstract code","version":3,"otp":"29.1.2","columns":60,"source_sha256":"2fc491ad480e74fded943bf072d5bfd452116a9dfc6dc7062860727fe487f1ab"}},"sources":[{"package":"libtmux_erlang","product":"core","version":"0.0.0+development","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"}],"symbols":[{"id":"tmux_buffer","publicId":"tmux_buffer","qualifiedName":"tmux_buffer","name":"tmux_buffer","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Load, inspect and paste tmux byte buffers through an explicit endpoint.","body":"Use `load/3` for binary payloads, including NUL bytes, and `show/2` to read\nthem back without terminal escaping or an added newline. `list/1` returns\ncaptured metadata in tmux's newest-first order; it never loads payloads.\n`paste/3` sends a named buffer to a registered pane. Direct input is available\nthrough `tmux_pane:send_text/2`.\n\nNames are NUL-free binaries, distinct from payload bytes. New names retain\ntmux's storage rules: 3.7+ cleans names and can reject control bytes or escape\nbackslashes. Use observed names from `list/1` for subsequent calls. Empty load\ninput is tmux's no-op; it neither creates nor clears a buffer. `delete/2`\nremoves a buffer explicitly. Names have no persistent object identity, and\nconcurrent commands can replace a buffer between calls.\n\nAll operations except `capabilities/1` perform explicit I/O. They use the\none-shot transport and preserve operational errors and ownership checks.\nThe [buffer guide](buffers.md) shows a complete byte round trip."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer"},{"id":"tmux_buffer:capabilities/1","publicId":"tmux_buffer:capabilities/1","qualifiedName":"tmux_buffer:capabilities/1","name":"capabilities/1","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"capabilities(Version)\n-spec capabilities(tmux_version:t()) -> capabilities().","references":[{"start":41,"end":55,"target":"t:tmux_version:t/0"},{"start":62,"end":74,"target":"t:tmux_buffer:capabilities/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"capabilities()","returnsReferences":[{"start":0,"end":12,"target":"t:tmux_buffer:capabilities/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe version differences without I/O. This does not qualify an untested release. `paste/3` uses paste_sanitize to gate sanitization and render raw paste.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3\">>), ok.\nok\n2> tmux_buffer:capabilities(V).\n#{paste_sanitize => false,cleaned_names => false,\n  rename_replaces => false,strict_named_target => false}"}]},"source":{"line":55,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-capabilities-1"},{"id":"tmux_buffer:delete/2","publicId":"tmux_buffer:delete/2","qualifiedName":"tmux_buffer:delete/2","name":"delete/2","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"delete(Server, Buffer)\n-spec delete(tmux_server:t(), target()) ->\n                {ok, tmux_operation:completed()} |\n                {error, map()}.","references":[{"start":36,"end":49,"target":"t:tmux_server:t/0"},{"start":53,"end":59,"target":"t:tmux_buffer:target/0"},{"start":87,"end":111,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":141,"end":144,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Delete a named buffer or latest. Missing buffers return buffer_not_found. This performs I/O and affects the server-wide buffer store.","body":"On 3.3/3.3a, named deletion first checks existence with a zero-output `show/3`\nread because native deletion falls back to the newest buffer when a name is\nabsent. This check does not collect a payload or depend on the list bounds.\nIt is not atomic: concurrent removal after the check can trigger that fallback.\nUse external serialization or tmux 3.4+ when that race is unacceptable."},"source":{"line":126,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-delete-2"},{"id":"tmux_buffer:list/1","publicId":"tmux_buffer:list/1","qualifiedName":"tmux_buffer:list/1","name":"list/1","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"list(Server)\n-spec list(tmux_server:t()) ->\n              {ok, [info()]} | {error, map()}.","references":[{"start":24,"end":37,"target":"t:tmux_server:t/0"},{"start":64,"end":68,"target":"t:tmux_buffer:info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":83,"end":86,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, [info()]} | {error, map()}","returnsReferences":[{"start":6,"end":10,"target":"t:tmux_buffer:info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture metadata in tmux's newest-first insertion order. Renaming preserves position; replacing data through `load/3` inserts a new buffer. Length frames preserve names containing delimiters, newlines or invalid UTF-8 on releases that permit them. Returns an ordinary list, bounded to 4096 rows and 1 MiB of encoded output. No payloads, hidden refresh or atomic snapshot is provided."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-list-1"},{"id":"tmux_buffer:load/3","publicId":"tmux_buffer:load/3","qualifiedName":"tmux_buffer:load/3","name":"load/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"load(Server, Name, Bytes)\n-spec load(tmux_server:t(),\n           binary() | automatic,\n           binary()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":37,"end":50,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":65,"end":71,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":98,"end":104,"target":"t:erlang:binary/0"},{"start":130,"end":154,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":182,"end":185,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Name","type":"binary() | automatic","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Bytes","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Load binary bytes under a name, or create an automatic buffer. Input may contain NUL. Empty input succeeds without changing the buffer store, including an existing name. The command payload, including argv and stdin, must fit the endpoint's 256 KiB admission limit. See `tmux_server:command/3`.","body":"Returns the completed command result, not a persistent buffer handle. No\nclipboard write is requested. Native stored-name rules still apply."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-load-3"},{"id":"tmux_buffer:paste/3","publicId":"tmux_buffer:paste/3","qualifiedName":"tmux_buffer:paste/3","name":"paste/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"paste(Pane, Buffer, Options)\n-spec paste(tmux_model:pane(), target(), paste_options()) ->\n               {ok, tmux_operation:completed()} |\n               {error, map()}.","references":[{"start":41,"end":56,"target":"t:tmux_model:pane/0"},{"start":60,"end":66,"target":"t:tmux_buffer:target/0"},{"start":70,"end":83,"target":"t:tmux_buffer:paste_options/0"},{"start":110,"end":134,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":163,"end":166,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]},{"name":"Options","type":"paste_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_buffer:paste_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send a named buffer or latest to a registered pane. Defaults preserve payload bytes: LF separators and unsanitized input. On tmux 3.7+, raw paste uses -S; sanitize=true selects its safe print encoding. Earlier releases reject that request with unsupported_capability before dispatch.","body":"separator is NUL-free; delete removes the buffer after the native paste call.\nbracketed adds markers only if the target has enabled that terminal mode.\nNative input-off/dead-pane behavior still applies. Completion establishes the\ntmux command result, not consumption by the child. No automatic retry occurs."},"source":{"line":167,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-paste-3"},{"id":"tmux_buffer:rename/3","publicId":"tmux_buffer:rename/3","qualifiedName":"tmux_buffer:rename/3","name":"rename/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Server, Old, New)\n-spec rename(tmux_server:t(), binary(), binary()) ->\n                {ok, tmux_operation:completed()} |\n                {error, map()}.","references":[{"start":38,"end":51,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":65,"end":71,"target":"t:erlang:binary/0"},{"start":99,"end":123,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":153,"end":156,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Old","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"New","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename one explicit name. tmux 3.3 refuses an occupied destination; 3.4+ replaces it. This is native collision behavior, not an atomic absence check. Identical input names return same_buffer_name before I/O, avoiding unsafe legacy tmux paths. New names retain native cleaning rules; see `list/1` for stored names. The same observed 3.3/3.3a missing-name preflight and race as `delete/2` apply."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-rename-3"},{"id":"tmux_buffer:show/2","publicId":"tmux_buffer:show/2","qualifiedName":"tmux_buffer:show/2","name":"show/2","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"show(Server, Buffer)\n-spec show(tmux_server:t(), target()) ->\n              {ok, binary()} | {error, map()}.","references":[{"start":32,"end":45,"target":"t:tmux_server:t/0"},{"start":49,"end":55,"target":"t:tmux_buffer:target/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":81,"end":87,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":101,"end":104,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read exact payload bytes with default bounds. See `show/3` for limits."},"source":{"line":81,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-show-2"},{"id":"tmux_buffer:show/3","publicId":"tmux_buffer:show/3","qualifiedName":"tmux_buffer:show/3","name":"show/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"show(Server, Buffer, Options)\n-spec show(tmux_server:t(), target(), read_options()) ->\n              {ok, binary()} | {error, map()}.","references":[{"start":41,"end":54,"target":"t:tmux_server:t/0"},{"start":58,"end":64,"target":"t:tmux_buffer:target/0"},{"start":68,"end":80,"target":"t:tmux_buffer:read_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":106,"end":112,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":126,"end":129,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_buffer:read_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read exact payload bytes from an unattached one-shot client. No print decoding or newline removal applies. max_bytes is 0 through 1 MiB; exceeding it returns output_limit with partial command evidence, never a successful truncated value. deadline_ms is 1 through 600000. Missing buffers return buffer_not_found."},"source":{"line":90,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_buffer-show-3"},{"id":"t:tmux_buffer:capabilities/0","publicId":"t:tmux_buffer:capabilities/0","qualifiedName":"tmux_buffer:capabilities/0","name":"capabilities/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capabilities() ::\n          #{paste_sanitize := boolean(),\n            cleaned_names := boolean(),\n            rename_replaces := boolean(),\n            strict_named_target := boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":54,"end":61,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":94,"end":101,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":136,"end":143,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":182,"end":189,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-defined buffer behavior for a parsed daemon version."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_buffer-capabilities-0"},{"id":"t:tmux_buffer:info/0","publicId":"t:tmux_buffer:info/0","qualifiedName":"tmux_buffer:info/0","name":"info/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type info() ::\n          #{name := binary(),\n            size := non_neg_integer(),\n            created := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":36,"end":42,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":108,"end":123,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Captured name, payload byte count and Unix creation time; not a live handle."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_buffer-info-0"},{"id":"t:tmux_buffer:paste_options/0","publicId":"t:tmux_buffer:paste_options/0","qualifiedName":"tmux_buffer:paste_options/0","name":"paste_options/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type paste_options() ::\n          #{separator => binary(),\n            delete => boolean(),\n            bracketed => boolean(),\n            sanitize => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":50,"end":56,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":82,"end":89,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":118,"end":125,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":153,"end":160,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Paste controls. separator defaults to LF; delete and bracketed default to false. sanitize defaults to false, preserving bytes. Explicit sanitization requires tmux 3.7+. Bracketing occurs only when the pane enables bracketed paste."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_buffer-paste_options-0"},{"id":"t:tmux_buffer:read_options/0","publicId":"t:tmux_buffer:read_options/0","qualifiedName":"tmux_buffer:read_options/0","name":"read_options/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type read_options() ::\n          #{max_bytes => 0..1048576,\n            deadline_ms => 1..600000}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read bounds: max_bytes defaults to 1 MiB; deadline_ms defaults to 2500."},"source":{"line":30,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_buffer-read_options-0"},{"id":"t:tmux_buffer:target/0","publicId":"t:tmux_buffer:target/0","qualifiedName":"tmux_buffer:target/0","name":"target/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type target() :: binary() | latest.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":18,"end":24,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A stored buffer name, or latest to let tmux select its newest buffer."},"source":{"line":26,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_buffer-target-0"},{"id":"tmux_capability","publicId":"tmux_capability","qualifiedName":"tmux_capability","name":"tmux_capability","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Look up source-derived native command declarations and feature minimums.","body":"`commands/1` and `command/2` describe the exact source profiles in `profiles/0`.\nProfiles cover every release in the supported tmux 3.3a–3.8 range. They do not\ncontact tmux, interpret its arguments or qualify another build.\nCanonical command names are lookup keys; aliases remain metadata. A native\ndeclaration does not mean this library provides a typed facade for it. Use\n`tmux_command:raw/2` for an explicit trusted command.\n\n`describe/1` reports selected native feature minimums. `require/2` compares a\nparsed version with one of those minimums; it does not perform I/O or dispatch\nthe command. Numeric minimum checks also accept uncatalogued and tracking\nversions, preserving the distinction from exact parser discovery. They do not\nestablish runtime or CI qualification. Use `tmux_server:version/1` to obtain the\nversion captured by a registered endpoint.\n\nThe [generated reference](commands-reference.md) records source profiles and\nparser declarations. Maintaining the catalogue needs a tmux source checkout;\ninstalled consumers use compiled data and OTP only."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability"},{"id":"tmux_capability:command/2","publicId":"tmux_capability:command/2","qualifiedName":"tmux_capability:command/2","name":"command/2","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"command(Version, Name)\n-spec command(tmux_version:t(), binary()) ->\n                 {ok, command_info()} | {error, map()}.","references":[{"start":37,"end":51,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"start":90,"end":102,"target":"t:tmux_capability:command_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":116,"end":119,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, command_info()} | {error, map()}","returnsReferences":[{"start":5,"end":17,"target":"t:tmux_capability:command_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up one canonical native command in an exact source profile. Returns unknown_command for aliases or unknown names, unsupported_command when a known command is absent from that profile, and unsupported_command_catalogue for uncatalogued or tracking versions. Performs no I/O.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3a\">>), ok.\nok\n2> {ok, C} = tmux_capability:command(V, <<\"send-keys\">>), ok.\nok\n3> maps:get(file, maps:get(source, C)).\n<<\"cmd-send-keys.c\">>"}]},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability-command-2"},{"id":"tmux_capability:commands/1","publicId":"tmux_capability:commands/1","qualifiedName":"tmux_capability:commands/1","name":"commands/1","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"commands(Version)\n-spec commands(tmux_version:t()) ->\n                  {ok, [binary()]} | {error, map()}.","references":[{"start":33,"end":47,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":78,"end":84,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":99,"end":102,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"{ok, [binary()]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return sorted canonical command names for an exact catalogued stable version. Tracking and uncatalogued versions return unsupported_command_catalogue. This is pure source discovery; it does not execute list-commands."},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability-commands-1"},{"id":"tmux_capability:describe/1","publicId":"tmux_capability:describe/1","qualifiedName":"tmux_capability:describe/1","name":"describe/1","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"describe/1\n-spec describe(feature()) ->\n                  {ok, feature_info()} | {error, map()}.","references":[{"start":26,"end":33,"target":"t:tmux_capability:feature/0"},{"start":63,"end":75,"target":"t:tmux_capability:feature_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"}],"params":[{"name":"Feature","type":"feature()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_capability:feature/0"}]}],"returns":"{ok, feature_info()} | {error, map()}","returnsReferences":[{"start":5,"end":17,"target":"t:tmux_capability:feature_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a selected native feature's source-derived minimum and sampled profiles. Unknown features return unknown_capability. Performs no I/O; `require/2` applies the minimum to a parsed version."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability-describe-1"},{"id":"tmux_capability:profiles/0","publicId":"tmux_capability:profiles/0","qualifiedName":"tmux_capability:profiles/0","name":"profiles/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"profiles()\n-spec profiles() -> [binary()].","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":32,"end":38,"target":"t:erlang:binary/0"}],"params":[],"returns":"[binary()]","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"List the exact source profile names in catalogue order. Performs no I/O."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability-profiles-0"},{"id":"tmux_capability:require/2","publicId":"tmux_capability:require/2","qualifiedName":"tmux_capability:require/2","name":"require/2","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"require(Version, Feature)\n-spec require(tmux_version:t(), feature()) ->\n                 ok | {error, map()}.","references":[{"start":40,"end":54,"target":"t:tmux_version:t/0"},{"start":58,"end":65,"target":"t:tmux_capability:feature/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":102,"end":105,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Feature","type":"feature()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_capability:feature/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Require a native feature's numeric major/minor floor without dispatching I/O. An older version returns unsupported_capability with capability and minimum. Patch letters and tracking markers do not promote an older minor version. Unknown features and malformed parsed versions return distinct errors.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.4\">>), ok.\nok\n2> tmux_capability:require(V, send_client_keys).\nok"}]},"source":{"line":122,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_capability-require-2"},{"id":"t:tmux_capability:command_info/0","publicId":"t:tmux_capability:command_info/0","qualifiedName":"tmux_capability:command_info/0","name":"command_info/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_info() ::\n          #{alias := binary() | none,\n            argument_spec := binary(),\n            min_args := non_neg_integer(),\n            max_args := non_neg_integer() | none,\n            source :=\n                #{file := binary(),\n                  commit := binary(),\n                  sha256 := binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":45,"end":51,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":91,"end":97,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":125,"end":140,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":168,"end":183,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":242,"end":248,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":280,"end":286,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":318,"end":324,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native alias, flag declaration and positional bounds, with the exact source file, commit and SHA-256. none means no alias or an unbounded positional upper limit. Additional argument callbacks and runtime checks remain tmux's concern."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_capability-command_info-0"},{"id":"t:tmux_capability:feature/0","publicId":"t:tmux_capability:feature/0","qualifiedName":"tmux_capability:feature/0","name":"feature/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type feature() ::\n          native_list_filter | send_client_keys |\n          key_list_format | layout_json.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Selected native capabilities; these do not introduce new typed command options."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_capability-feature-0"},{"id":"t:tmux_capability:feature_info/0","publicId":"t:tmux_capability:feature_info/0","qualifiedName":"tmux_capability:feature_info/0","name":"feature_info/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type feature_info() ::\n          #{minimum :=\n                {non_neg_integer(), non_neg_integer()},\n            commands := [binary()],\n            description := binary(),\n            versions := [binary()]}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":64,"end":79,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":83,"end":98,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":128,"end":134,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":166,"end":172,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":201,"end":207,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-sampled profiles, native commands, description and numeric minimum."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_capability-feature_info-0"},{"id":"tmux_command","publicId":"tmux_command","qualifiedName":"tmux_command","name":"tmux_command","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Build tmux commands and bounded sequences without performing I/O.","body":"Arguments remain binary values. Rendering protects trailing semicolons from\ntmux's command separator parser. This is distinct from shell quoting and from\nformat expansion. A raw command is trusted application code; external services\nmust apply their own command allowlist and write policy.\n\nUse `literal_format/1` only for a whole argument that tmux\nexpands as a format, such as a new name or cwd. It does not encode a value\nnested in a format expression. tmux's stored-name escaping and session-name\nsubstitutions still apply. Use `literal_format/2` with mode time\nfor commands such as display-message that also expand strftime percent\ndirectives. This protects one format-expansion pass, not later visual style\nrendering or recursive/nested expansion. No renderer reverses stored-name\nsemantics.\n\n`launch/1` distinguishes executable argv from an explicitly\nrequested shell command. A singleton argv uses the installed helper's\nexec-only mode because tmux otherwise passes one argument to its default\nshell. Empty argv is invalid; default_shell explicitly requests tmux's\nconfigured default command/shell. The internal helper uses an absolute path so\na child's cwd does not change helper resolution. Relative executable arguments\nretain their native meaning.\n\nEmpty shell commands have command-specific lifetime. split-window creates a\nprocess-free pane. new-session executes an empty shell command and can remove\nthe new object immediately. new-window does likewise before tmux 3.8; tmux 3.8\ncreates a process-free pane. Use a persistent job for parent sessions/windows\nthat must remain available across supported versions.\n\nSubmit commands through `tmux_server:command/3` or `tmux_operation:start/3`.\n`sequence/1` combines flat command values for one-shot execution with combined\noutput and a possible completed prefix on error.\nThe [job guide](jobs.md) shows submission, completion and cancellation.\n`tmux_session:rename_command/2` and `tmux_pane:resize_command/2` build values\nbound to their row's captured origin. Execution through another endpoint\nreturns different_owner before native work. Construction does not validate\nendpoint liveness or authorize an automatic mutation retry.\n\n`wait_for/2` builds native channel signals, waits and advisory locks.\n`source_file/2` builds configuration loading from stdin or a literal absolute\npath. Both return command values without opening an endpoint or doing I/O.\n`to_config/1` renders a command or bounded command list for native\nconfiguration input, preserving argument bytes through tmux's lexer.","examples":[{"lang":"erlang","code":"1> {ok, C} = tmux_command:raw(<<\"list-panes\">>, [<<\"-a\">>]), ok.\nok\n2> tmux_command:argv(C).\n[<<\"list-panes\">>,<<\"-a\">>]\n3> tmux_command:literal_format(<<\"api-#{pane_id}\">>).\n{ok,<<\"api-##{pane_id}\">>}\n4> tmux_command:launch(#{argv => [<<\"/bin/printf\">>, <<\"hello\">>]}).\n{ok,[<<\"/bin/printf\">>,<<\"hello\">>]}"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command"},{"id":"tmux_command:argv/1","publicId":"tmux_command:argv/1","qualifiedName":"tmux_command:argv/1","name":"argv/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"argv(Command)\n-spec argv(t()) -> [binary()].","references":[{"start":25,"end":26,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":34,"end":40,"target":"t:erlang:binary/0"}],"params":[{"name":"Command","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_command:t/0"}]}],"returns":"[binary()]","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render a validated command into executable argv, protecting trailing tmux separators. Performs no I/O and raises for an invalid command value."},"source":{"line":299,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-argv-1"},{"id":"tmux_command:launch/1","publicId":"tmux_command:launch/1","qualifiedName":"tmux_command:launch/1","name":"launch/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"launch/1\n-spec launch(launch_spec()) ->\n                {ok, [binary()]} | {error, map()}.","references":[{"start":22,"end":33,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":62,"end":68,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":83,"end":86,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"launch_spec()","typeReferences":[{"start":0,"end":11,"target":"t:tmux_command:launch_spec/0"}]}],"returns":"{ok, [binary()]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render explicit executable argv, an explicitly requested shell command, or default_shell. Singleton argv uses the installed helper's exec-only mode to avoid tmux interpreting it as shell syntax. Performs no I/O."},"source":{"line":448,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-launch-1"},{"id":"tmux_command:literal_format/1","publicId":"tmux_command:literal_format/1","qualifiedName":"tmux_command:literal_format/1","name":"literal_format/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"literal_format(Value)\n-spec literal_format(binary()) ->\n                        {ok, binary()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":85,"end":91,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":105,"end":108,"target":"t:erlang:map/0"}],"params":[{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Quote a complete literal argument for tmux format expansion. This does not encode operands nested inside another format expression. Performs no I/O."},"source":{"line":389,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-literal_format-1"},{"id":"tmux_command:literal_format/2","publicId":"tmux_command:literal_format/2","qualifiedName":"tmux_command:literal_format/2","name":"literal_format/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"literal_format/2\n-spec literal_format(binary(), tmux | time) ->\n                        {ok, binary()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":38,"end":44,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":93,"end":99,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"}],"params":[{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Mode","type":"tmux | time","typeReferences":[]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Quote a complete literal format argument. Mode tmux protects hash expansion; mode time also protects strftime percent directives. Stored-name semantics remain tmux's own. This handles one expansion pass, not a nested operand, recursive expansion or later visual style rendering. Performs no I/O.","body":"Hash runs before `[` stay unchanged because tmux preserves style-looking\nprefixes for a separate drawing step. Other hashes are doubled. In time mode,\nan argument containing percent bytes must fit tmux's 8191-byte strftime result\nlimit after hash encoding and before percent doubling; larger values return\n`format_limit` with `time_bytes` and `max_bytes`. Arguments without percent\nbytes skip that native time-expansion limit. The encoded 32 KiB command limit\nstill applies in either mode."},"source":{"line":407,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-literal_format-2"},{"id":"tmux_command:raw/2","publicId":"tmux_command:raw/2","qualifiedName":"tmux_command:raw/2","name":"raw/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"raw(Name, Arguments)\n-spec raw(binary(), [binary()]) ->\n             {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":31,"end":37,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":42,"end":48,"target":"t:erlang:binary/0"},{"start":74,"end":75,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"}],"params":[{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Arguments","type":"[binary()]","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate one trusted command name and binary argv, without I/O. The renderer protects tmux separators; it does not provide shell or nested-format quoting. External services still need their own allowlists and write policy. Names are at most 128 bytes. NUL bytes are rejected, and at most 2,040 arguments fit within a 32 KiB command reservation including framing overhead."},"source":{"line":100,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-raw-2"},{"id":"tmux_command:sequence/1","publicId":"tmux_command:sequence/1","qualifiedName":"tmux_command:sequence/1","name":"sequence/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"sequence/1\n-spec sequence([t(), ...]) -> {ok, t()} | {error, map()}.","references":[{"start":27,"end":28,"target":"t:tmux_command:t/0"},{"start":46,"end":47,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":61,"end":64,"target":"t:erlang:map/0"}],"params":[{"name":"Commands","type":"[t(), ...]","typeReferences":[{"start":1,"end":2,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build one bounded native command sequence without I/O. Members must be a nonempty flat list of at most 256 command values. Their combined executable argv is limited to 2041 words and 32 KiB including separator overhead. Arguments keep the literal separator protection of `raw/2`; only boundaries between members become native command separators in `argv/1`.","body":"Captured members must share an endpoint origin. That origin also binds the\nsequence; raw members use the caller's explicitly selected endpoint. Submit\nthrough `tmux_server:command/3` or `tmux_operation:start/3`.\n\nExecution is not atomic. A failed member can leave a completed prefix, and\ncommands can wait or interleave with other work. The one-shot result contains\ncombined bounded stdout/stderr and native exit status, without per-member\ncompletion attribution or rollback. Control-mode eligibility is separate.\n`to_config/1` can serialize a sequence with the same origin-loss policy as\nother configuration text."},"source":{"line":129,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-sequence-1"},{"id":"tmux_command:source_file/2","publicId":"tmux_command:source_file/2","qualifiedName":"tmux_command:source_file/2","name":"source_file/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"source_file(Source, Options)\n-spec source_file(source(), source_options()) ->\n                     {ok, t()} | {error, map()}.","references":[{"start":47,"end":53,"target":"t:tmux_command:source/0"},{"start":57,"end":71,"target":"t:tmux_command:source_options/0"},{"start":104,"end":105,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":119,"end":122,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"source()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_command:source/0"}]},{"name":"Options","type":"source_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:source_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build configuration loading from stdin or one literal absolute path, without I/O. `stdin` renders `source-file -`; supply configuration bytes in the `stdin` option of `tmux_server:command/3` or `tmux_operation:start/3`. Those APIs bound input to 256 KiB including their argument reservation.","body":"Paths are NUL-free POSIX byte binaries. Glob metacharacters and backslashes\nare escaped so only that filename is selected; format expansion is disabled.\nThe combined encoded path and flags must fit `raw/2` limits. The file is read\nby tmux at execution time; this builder does not open it or bound its size.\n\n`parse_only` requests native `-n` parsing without executing the configuration's\ncommand list. `quiet` requests native `-q` missing-file suppression; it does\nnot suppress syntax or execution errors. Both default to false. Configuration\nis trusted tmux code, with its own variable, directive and command semantics.\nParse-only is not a sandbox. Execution can partially change server state before\nan error; cancellation cannot undo those effects. Completion does not prove\nthat background jobs launched by the configuration have finished.","examples":[{"lang":"erlang","code":"1> {ok, Source} = tmux_command:source_file(stdin, #{parse_only => true}), ok.\nok\n2> tmux_command:argv(Source).\n[<<\"source-file\">>,<<\"-n\">>,<<\"--\">>,<<\"-\">>]"}]},"source":{"line":228,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-source_file-2"},{"id":"tmux_command:to_config/1","publicId":"tmux_command:to_config/1","qualifiedName":"tmux_command:to_config/1","name":"to_config/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"to_config/1\n-spec to_config(t() | [t(), ...]) ->\n                   {ok, binary()} | {error, map()}.","references":[{"start":28,"end":29,"target":"t:tmux_command:t/0"},{"start":35,"end":36,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":73,"end":79,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"t() | [t(), ...]","typeReferences":[{"start":0,"end":1,"target":"t:tmux_command:t/0"},{"start":7,"end":8,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render validated commands as native configuration text, without I/O. Accepts one command, a `sequence/1` value, or a nonempty flat list of at most 256 commands. Returns an ASCII binary of at most 32 KiB, without a final newline. Validation uses `validate/1`; escaping growth, command count and aggregate size can return `command_limit`. Lists use native command separators between independently quoted commands. Rendering does not execute them or provide atomic execution or rollback. The text carries no origin token; executing serialized configuration requires the caller to choose and validate its destination explicitly.","body":"Each argument is doublequoted. Quote, backslash, dollar, tilde, control and\nnon-ASCII bytes use three-digit octal escapes. Empty arguments, semicolons,\nnewlines and non-UTF-8 byte values remain argument data. The lexer does not\nexpand their variables or tilde prefixes, strip newline indentation, or\ninterpret them as directives, comments or additional commands.\n\nProtection covers one lexer pass. Native command-string arguments, including\n`bind-key` and `set-hook` values, can be parsed again by the receiving command.\nRender each inner command string separately for its own parse boundary.\n\nThis is tmux configuration syntax, separate from `argv/1` executable arguments\nand shell quoting. Native commands still interpret their values and expand\nformats as usual; `literal_format/2` handles that separate boundary when\nliteral format values are required. Load the text explicitly with\n`source_file/2`, or store it through a native command that accepts configuration\ntext. The [configuration guide](configuration.md) uses this renderer with\nexplicit execution and completion signals."},"source":{"line":340,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-to_config-1"},{"id":"tmux_command:validate/1","publicId":"tmux_command:validate/1","qualifiedName":"tmux_command:validate/1","name":"validate/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"validate/1\n-spec validate(term()) -> {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":26,"end":30,"target":"t:erlang:term/0"},{"start":42,"end":43,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":57,"end":60,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Revalidate a command value at a submission boundary. Returns a compact validated command or a tagged shape/argument/resource error, without I/O."},"source":{"line":252,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-validate-1"},{"id":"tmux_command:wait_for/2","publicId":"tmux_command:wait_for/2","qualifiedName":"tmux_command:wait_for/2","name":"wait_for/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"wait_for(Channel, Action)\n-spec wait_for(binary(), wait_action()) ->\n                  {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":51,"end":62,"target":"t:tmux_command:wait_action/0"},{"start":92,"end":93,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":107,"end":110,"target":"t:erlang:map/0"}],"params":[{"name":"Channel","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Action","type":"wait_action()","typeReferences":[{"start":0,"end":11,"target":"t:tmux_command:wait_action/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a native `wait-for` command without I/O. Channels are nonempty NUL-free binary names, subject to the command reservation in `raw/2`; neither shell nor format expansion occurs. Submit through `tmux_operation:start/3` for a wait that leaves the caller free, or through `tmux_server:command/3` to await it.","body":"`signal` wakes current waiters. On an unlocked channel with no waiters or\npending wakeup, it retains one wakeup for a later wait. Signaling that channel\nagain before a wait can clear the pending state. Signals are neither counted\nnor reliably coalesced events; send once per expected wait. Channel names are\nshared by all clients of the server. Use separate names for signaling and\nlocking. `lock` acquires an advisory channel lock or waits\nfor an explicit `unlock`; a completed command client's exit does not release\nits acquired lock. Unlocking an unlocked channel is a native command error.\n\nCancellation retires the library client. It does not undo a signal or release\na lock that may already have been acquired; an uncertain lock outcome needs\napplication coordination before another unlock. This is not an owned mutex.","examples":[{"lang":"erlang","code":"1> {ok, Signal} = tmux_command:wait_for(<<\"build-ready\">>, signal), ok.\nok\n2> tmux_command:argv(Signal).\n[<<\"wait-for\">>,<<\"-S\">>,<<\"--\">>,<<\"build-ready\">>]"}]},"source":{"line":188,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_command-wait_for-2"},{"id":"t:tmux_command:launch_spec/0","publicId":"t:tmux_command:launch_spec/0","qualifiedName":"tmux_command:launch_spec/0","name":"launch_spec/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type launch_spec() ::\n          default_shell |\n          #{argv := [binary(), ...]} |\n          #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":70,"end":76,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":109,"end":115,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicit executable argv, an explicitly requested shell command, or tmux's configured default shell."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-launch_spec-0"},{"id":"t:tmux_command:respawn_spec/0","publicId":"t:tmux_command:respawn_spec/0","qualifiedName":"tmux_command:respawn_spec/0","name":"respawn_spec/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_spec() ::\n          previous |\n          #{argv := [binary(), ...]} |\n          #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":66,"end":72,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":105,"end":111,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Reuse tmux's saved command/shell, or replace it with argv or a shell command. Used by `tmux_pane:respawn/2` and `tmux_window:respawn/2`."},"source":{"line":81,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-respawn_spec-0"},{"id":"t:tmux_command:source/0","publicId":"t:tmux_command:source/0","qualifiedName":"tmux_command:source/0","name":"source/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source() :: stdin | binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":26,"end":32,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Standard input, or one literal absolute POSIX byte path with no NUL."},"source":{"line":68,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-source-0"},{"id":"t:tmux_command:source_options/0","publicId":"t:tmux_command:source_options/0","qualifiedName":"tmux_command:source_options/0","name":"source_options/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_options() ::\n          #{parse_only => boolean(), quiet => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":52,"end":59,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":72,"end":79,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native parse-only and quiet-missing-file flags; both default to false."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-source_options-0"},{"id":"t:tmux_command:t/0","publicId":"t:tmux_command:t/0","qualifiedName":"tmux_command:t/0","name":"t/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated command or flat sequence. Rendering and execution remain separate. Domain builders retain a captured endpoint origin; raw values are unbound."},"source":{"line":87,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-t-0"},{"id":"t:tmux_command:wait_action/0","publicId":"t:tmux_command:wait_action/0","qualifiedName":"tmux_command:wait_action/0","name":"wait_action/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type wait_action() :: wait | signal | lock | unlock.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native wait channel action. lock/unlock are explicit advisory operations, not owned leases."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_command-wait_action-0"},{"id":"tmux_control","publicId":"tmux_control","qualifiedName":"tmux_control","name":"tmux_control","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Own an explicit persistent tmux control attachment.","body":"`attach/3` attaches to an existing session from `m:tmux_server` and verifies\nthe daemon identity on that connection. The caller owns its lifetime.\nAttachment changes the session's attached-client count. The command client\nuses no-output and ignore-size; -E skips attachment's environment update.\nThe library issues no session-option writes or session-creation commands.\nConfigured hooks and native lifetime policies can still change state,\nincluding on failed attach or detachment. Those effects are not rolled back.\nCommand submission and terminal streaming are not yet exposed.\n\nUse `close/1` before closing the parent endpoint. Parent closing, invalidation\nor caller death requests retirement, but parent close alone does not prove\nthis client's exit. Control close and `status/1` report its native cleanup.\nNeither detachment nor cancellation reverses remote effects. Application\nshutdown alone is not a verified cleanup result."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_control"},{"id":"tmux_control:attach/3","publicId":"tmux_control:attach/3","qualifiedName":"tmux_control:attach/3","name":"attach/3","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"attach(Server, Session, Options)\n-spec attach(tmux_server:t(),\n             tmux_model:session(),\n             attach_options()) ->\n                {ok, t()} | {error, map()}.","references":[{"start":46,"end":59,"target":"t:tmux_server:t/0"},{"start":76,"end":94,"target":"t:tmux_model:session/0"},{"start":111,"end":125,"target":"t:tmux_control:attach_options/0"},{"start":153,"end":154,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":168,"end":171,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"attach_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_control:attach_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Attach to an existing captured session from this exact endpoint origin. Performs I/O and waits for a same-connection identity probe. Uses attach-session with -E rather than creating a session or writing options. Configured hooks may change state; failure does not reverse their effects. The control client affects attached_count. Unexpected hook-generated reply blocks fail attachment and retire the client.","body":"An attachment timeout requests cleanup. If cleanup cannot be proved within\nits finite deadline, the error includes a control handle for `close/1` recovery.\nThe supervised owner remains until native retirement. Close explicitly to\nobserve cleanup, including when the parent endpoint is already closed."},"source":{"line":55,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_control-attach-3"},{"id":"tmux_control:close/1","publicId":"tmux_control:close/1","qualifiedName":"tmux_control:close/1","name":"close/1","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"close(Control)\n-spec close(t()) -> ok | {error, map()}.","references":[{"start":27,"end":28,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":48,"end":51,"target":"t:erlang:map/0"}],"params":[{"name":"Control","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_control:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Retire this control client and its helper without issuing session or daemon destruction commands. Native lifetime policies and detachment hooks may still change state; cleanup does not reverse their effects. Returns ok only after actual retirement. A finite cleanup failure leaves a supervised owner for retry and observation. Successful close is idempotent during the 60-second handle retention period."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_control-close-1"},{"id":"tmux_control:status/1","publicId":"tmux_control:status/1","qualifiedName":"tmux_control:status/1","name":"status/1","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"status(Control)\n-spec status(t()) -> {ok, state()} | {error, map()}.","references":[{"start":29,"end":30,"target":"t:tmux_control:t/0"},{"start":42,"end":47,"target":"t:tmux_control:state/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":61,"end":64,"target":"t:erlang:map/0"}],"params":[{"name":"Control","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_control:t/0"}]}],"returns":"{ok, state()} | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_control:state/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":24,"end":27,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read retained connection state without a tmux command. Inspect cleanup rather than inferring native exit from the Erlang owner's lifecycle. Closed handles expire after 60 seconds and then return control_expired."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_control-status-1"},{"id":"t:tmux_control:attach_options/0","publicId":"t:tmux_control:attach_options/0","qualifiedName":"tmux_control:attach_options/0","name":"attach_options/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type attach_options() ::\n          #{startup_timeout_ms => 1..600000}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Finite attachment budget, including parent registration, exec and identity. Defaults to 2500 ms."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_control-attach_options-0"},{"id":"t:tmux_control:state/0","publicId":"t:tmux_control:state/0","qualifiedName":"tmux_control:state/0","name":"state/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := attaching | open | closing | closed,\n            generation := reference(),\n            owner := pid(),\n            identity := unverified | same_connection,\n            cleanup := pending | incomplete | complete,\n            child_pid := none | pos_integer(),\n            helper_pid := none | pos_integer(),\n            cause := none | atom()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":101,"end":110,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":135,"end":138,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":284,"end":295,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":332,"end":343,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":375,"end":379,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Connection state, separate from command completion. complete proves native client/helper retirement; pending and incomplete do not. Retained PIDs are diagnostic observations, never permission to signal a process."},"source":{"line":35,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_control-state-0"},{"id":"t:tmux_control:t/0","publicId":"t:tmux_control:t/0","qualifiedName":"tmux_control:t/0","name":"t/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A generation-bound connection handle. Passing it does not transfer lifetime ownership."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_control-t-0"},{"id":"tmux_error","publicId":"tmux_error","qualifiedName":"tmux_error","name":"tmux_error","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Explain library exceptions through Erlang's native error formatter.","body":"The shell and `erl_error:format_exception/3` call `format_error/2` through\nEEP-54 stack metadata. Explanations supplement the original exception reason;\ntagged results from `tmux_filter:new/2` and `tmux_select:try_where/2` retain\ntheir existing structured data. Formatting performs no tmux I/O.\n\nOnly library-raised errors carry this metadata. Application callback failures\nretain their original class, reason and stack. Coverage errors describe missing\nobservations; formatting never loads those observations or retries an action.\nLong detail values may be abbreviated in the explanation. The exception reason\nretains the original error data. See [runtime diagnostics](diagnostics.md) for\nthe separate, bounded Logger report contract."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_error.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_error"},{"id":"tmux_error:format_error/2","publicId":"tmux_error:format_error/2","qualifiedName":"tmux_error:format_error/2","name":"format_error/2","namespace":"tmux_error","parent":"tmux_error","kind":"function","modifiers":[],"signatures":[{"raw":"format_error/2\n-spec format_error(term(), erlang:stacktrace()) ->\n                      #{general => unicode:chardata()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":34,"end":38,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":42,"end":59,"target":"t:erlang:stacktrace/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/unicode.html#t:chardata/0","project":"Erlang/OTP"},"start":101,"end":117,"target":"t:unicode:chardata/0"}],"params":[{"name":"Argument1","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Argument2","type":"erlang:stacktrace()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":0,"end":17,"target":"t:erlang:stacktrace/0"}]}],"returns":"#{general => unicode:chardata()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/unicode.html#t:chardata/0","project":"Erlang/OTP"},"start":13,"end":29,"target":"t:unicode:chardata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return supplemental native error text, or an empty map for an unknown reason.","body":"This is the `c:erl_error:format_error/2` callback. It neither changes the\nexception nor catches it on behalf of a caller.","examples":[{"lang":"erlang","code":"1> #{general := Text} = tmux_error:format_error({bad_query_limit, -1}, []), ok.\nok\n2> unicode:characters_to_binary(Text).\n<<\"The query limit must be an integer from 0 through 65536.\">>"}]},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_error.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_error-format_error-2"},{"id":"tmux_filter","publicId":"tmux_filter","qualifiedName":"tmux_filter","name":"tmux_filter","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Construct portable conditions and prepare them against captured values.","body":"Local criteria use atom keys, binary text and schema-typed values. Fields and\noperators conjoin. Boolean branches use 'and', 'or' and 'not'; relationships\nuse some/every/none/count or is/is_not. Validation examines the entire input\nbefore evaluation. No function here performs tmux I/O. Use portable filters\nwith `tmux_select:where/2` or `tmux_query:where/2`; the [query\nguide](querying.md) explains their different execution boundaries.\n\nWire version 1 uses generated camelCase field names, snake_case operators,\nJSON null for known absence and {\"base64\": \"...\"} for byte operands. Byte\nvalues never become text implicitly. Regex uses the restricted ASCII\nportable_v1 dialect, absolute anchors and no flags. Preparation compiles each\npattern once. Non-ASCII subjects and exhausted match limits return errors.\n\nBoth input criteria and their normalized wire document must fit the grammar,\ndepth and byte limits. Resource errors can refer to the canonical wire path.","examples":[{"lang":"erlang","code":"1> Fields = #{id => <<\"%1\">>, current_command => <<\"vim\">>}, ok.\nok\n2> {ok, P} = tmux_model:pane(Fields), S = tmux_select:from_list(pane, [P]), ok.\nok\n3> R = #{pattern => <<\"^(vim|nvim)$\">>, dialect => portable_v1}, ok.\nok\n4> tmux_select:size(tmux_select:where(#{current_command => #{regex => R}}, S)).\n1"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter"},{"id":"tmux_filter:decode_json/1","publicId":"tmux_filter:decode_json/1","qualifiedName":"tmux_filter:decode_json/1","name":"decode_json/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"decode_json(Binary)\n-spec decode_json(binary()) ->\n                     {ok, json:decode_value()} |\n                     {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":38,"end":44,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":77,"end":94,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":129,"end":132,"target":"t:erlang:map/0"}],"params":[{"name":"Binary","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, json:decode_value()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":5,"end":22,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Decode bounded external JSON with duplicate-key, trailing-input and depth checks. Returns tagged errors with input paths. Parsing does not execute tmux or choose application modules."},"source":{"line":135,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-decode_json-1"},{"id":"tmux_filter:entity/1","publicId":"tmux_filter:entity/1","qualifiedName":"tmux_filter:entity/1","name":"entity/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"entity/1\n-spec entity(t()) -> tmux_schema:entity().","references":[{"start":22,"end":23,"target":"t:tmux_filter:t/0"},{"start":30,"end":48,"target":"t:tmux_schema:entity/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"tmux_schema:entity()","returnsReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the schema entity this portable filter accepts, without I/O."},"source":{"line":141,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-entity-1"},{"id":"tmux_filter:from_wire/2","publicId":"tmux_filter:from_wire/2","qualifiedName":"tmux_filter:from_wire/2","name":"from_wire/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"from_wire(Entity, Document)\n-spec from_wire(tmux_schema:entity(), term()) ->\n                   {ok, t()} | {error, map()}.","references":[{"start":44,"end":62,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":66,"end":70,"target":"t:erlang:term/0"},{"start":101,"end":102,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":116,"end":119,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Document","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate a versioned filter document using generated wire-name allowlists. Rejects unknown fields, operators, wrong entity/version and resource limits. No payload key becomes an atom; this does not execute a query."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-from_wire-2"},{"id":"tmux_filter:matches/2","publicId":"tmux_filter:matches/2","qualifiedName":"tmux_filter:matches/2","name":"matches/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"matches(Prepared, Row)\n-spec matches(prepared(), tmux_model:row()) ->\n                 {ok, boolean()} | {error, map()}.","references":[{"start":37,"end":45,"target":"t:tmux_filter:prepared/0"},{"start":49,"end":63,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":92,"end":99,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"}],"params":[{"name":"Prepared","type":"prepared()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_filter:prepared/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]}],"returns":"{ok, boolean()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":5,"end":12,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":26,"end":29,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Evaluate an unmodified captured row against a prepared filter. Returns a Boolean result or tagged context/regex resource error. It performs no tmux I/O and never converts evaluation failure into a nonmatch."},"source":{"line":223,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-matches-2"},{"id":"tmux_filter:new/2","publicId":"tmux_filter:new/2","qualifiedName":"tmux_filter:new/2","name":"new/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"new/2\n-spec new(tmux_schema:entity(), map() | t()) ->\n             {ok, t()} | {error, map()}.","references":[{"start":16,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"start":46,"end":47,"target":"t:tmux_filter:t/0"},{"start":72,"end":73,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":87,"end":90,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Filter","type":"map() | t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":9,"target":"t:tmux_filter:t/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria or reuse an already normalized filter for the same entity.","examples":[{"lang":"erlang","code":"1> {ok, F} = tmux_filter:new(pane, #{width => #{gte => 120.0}}), ok.\nok\n2> tmux_filter:new(pane, F) =:= {ok, F}.\ntrue\n3> tmux_filter:new(pane, #{active => #{contains => <<\"yes\">>}}).\n{error,#{code => unsupported_operator,path => [active,contains],allowed => [equals,'not',in,not_in]}}"}]},"source":{"line":75,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-new-2"},{"id":"tmux_filter:new_or_error/2","publicId":"tmux_filter:new_or_error/2","qualifiedName":"tmux_filter:new_or_error/2","name":"new_or_error/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"new_or_error(Entity, Criteria)\n-spec new_or_error(tmux_schema:entity(), map() | t()) ->\n                      t().","references":[{"start":50,"end":68,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":72,"end":75,"target":"t:erlang:map/0"},{"start":80,"end":81,"target":"t:tmux_filter:t/0"},{"start":110,"end":111,"target":"t:tmux_filter:t/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Criteria","type":"map() | t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":9,"target":"t:tmux_filter:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a normalized portable filter, raising bad_filter on malformed trusted criteria. Performs no tmux I/O. External input should use `new/2` or `from_wire/2` for tagged validation errors."},"source":{"line":86,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-new_or_error-2"},{"id":"tmux_filter:predicate/1","publicId":"tmux_filter:predicate/1","qualifiedName":"tmux_filter:predicate/1","name":"predicate/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"predicate(Prepared)\n-spec predicate(prepared()) ->\n                   fun((tmux_model:row()) -> boolean()).","references":[{"start":36,"end":44,"target":"t:tmux_filter:prepared/0"},{"start":75,"end":89,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":96,"end":103,"target":"t:erlang:boolean/0"}],"params":[{"name":"Prepared","type":"prepared()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_filter:prepared/0"}]}],"returns":"fun((tmux_model:row()) -> boolean())","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":26,"end":33,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a Boolean function bound to the prepared observation context.","body":"Rows outside that context raise {prepared_context_mismatch, Detail}. Regex\nevaluation errors raise {filter_evaluation_failed, Detail}. Use `matches/2`\nfor tagged errors. This does not run callbacks."},"source":{"line":205,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-predicate-1"},{"id":"tmux_filter:prepare/2","publicId":"tmux_filter:prepare/2","qualifiedName":"tmux_filter:prepare/2","name":"prepare/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"prepare/2\n-spec prepare(t(), tmux_snapshot:t()) ->\n                 {ok, prepared()} | {error, map()}.","references":[{"start":24,"end":25,"target":"t:tmux_filter:t/0"},{"start":29,"end":44,"target":"t:tmux_snapshot:t/0"},{"start":73,"end":81,"target":"t:tmux_filter:prepared/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":95,"end":98,"target":"t:erlang:map/0"}],"params":[{"name":"Filter","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]},{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, prepared()} | {error, map()}","returnsReferences":[{"start":5,"end":13,"target":"t:tmux_filter:prepared/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Bind a filter to one snapshot and check all required coverage first.","body":"The prepared value can match only unmodified rows captured in that snapshot.\nIt remains usable after the endpoint closes. It cannot refresh observations.","examples":[{"lang":"erlang","code":"1> {ok, F} = tmux_filter:new(pane, #{width => #{gte => 80}}), ok.\nok\n2> tmux_filter:requirements(F).\n[{collection,pane},{field,pane,width}]"}]},"source":{"line":178,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-prepare-2"},{"id":"tmux_filter:requirements/1","publicId":"tmux_filter:requirements/1","qualifiedName":"tmux_filter:requirements/1","name":"requirements/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"requirements/1\n-spec requirements(t()) -> [tmux_snapshot:requirement()].","references":[{"start":34,"end":35,"target":"t:tmux_filter:t/0"},{"start":43,"end":68,"target":"t:tmux_snapshot:requirement/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"[tmux_snapshot:requirement()]","returnsReferences":[{"start":1,"end":26,"target":"t:tmux_snapshot:requirement/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Derive every field and complete relationship needed for faithful evaluation. The complete requirement set is checked before short-circuiting any row."},"source":{"line":161,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-requirements-1"},{"id":"tmux_filter:to_wire/1","publicId":"tmux_filter:to_wire/1","qualifiedName":"tmux_filter:to_wire/1","name":"to_wire/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"to_wire/1\n-spec to_wire(t()) -> wire_document().","references":[{"start":24,"end":25,"target":"t:tmux_filter:t/0"},{"start":32,"end":45,"target":"t:tmux_filter:wire_document/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"wire_document()","returnsReferences":[{"start":0,"end":13,"target":"t:tmux_filter:wire_document/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Export versioned JSON-compatible predicate data with generated wire names. Byte operands use base64 objects and known absence uses JSON null. Functions, compiled regexes and native record internals never enter this representation."},"source":{"line":125,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_filter-to_wire-1"},{"id":"t:tmux_filter:expr/0","publicId":"t:tmux_filter:expr/0","qualifiedName":"tmux_filter:expr/0","name":"expr/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type expr() ::\n          {all | any, [expr()]} |\n          {negate, expr()} |\n          {field, binary(), atom(), term()} |\n          {relation, binary(), atom(), expr()} |\n          {count, binary(), [{atom(), term()}]}.","params":[],"references":[{"start":39,"end":43,"target":"t:tmux_filter:expr/0"},{"start":69,"end":73,"target":"t:tmux_filter:expr/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":97,"end":103,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":107,"end":111,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":115,"end":119,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":146,"end":152,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":156,"end":160,"target":"t:erlang:atom/0"},{"start":164,"end":168,"target":"t:tmux_filter:expr/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":192,"end":198,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":204,"end":208,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":212,"end":216,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Normalized data expressions with stable field IDs, used by internal planners; not the wire grammar."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_filter-expr-0"},{"id":"t:tmux_filter:prepared/0","publicId":"t:tmux_filter:prepared/0","qualifiedName":"tmux_filter:prepared/0","name":"prepared/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque prepared().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A cached evaluator bound to one captured observation and schema context."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_filter-prepared-0"},{"id":"t:tmux_filter:t/0","publicId":"t:tmux_filter:t/0","qualifiedName":"tmux_filter:t/0","name":"t/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Portable normalized predicate data for one schema entity; contains no executable state."},"source":{"line":40,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_filter-t-0"},{"id":"t:tmux_filter:wire_document/0","publicId":"t:tmux_filter:wire_document/0","qualifiedName":"tmux_filter:wire_document/0","name":"wire_document/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type wire_document() :: #{binary() => json:encode_value()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:encode_value/0","project":"Erlang/OTP"},"start":39,"end":56,"target":"t:json:encode_value/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Version-one JSON-compatible filter envelope with binary keys version, entity and where. entity is the generated wire entity name; where contains Boolean, field and relationship conditions. Version is the integer 1. Keys and operators still require `from_wire/2` validation; the typespec alone does not authorize arbitrary fields or unbounded external input."},"source":{"line":57,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_filter-wire_document-0"},{"id":"tmux_hook","publicId":"tmux_hook","qualifiedName":"tmux_hook","name":"tmux_hook","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Store builtin hook commands and run them in an explicit observed context.","body":"`set/3` replaces one indexed entry. `append/3` uses tmux's first vacant index;\n`clear/2` leaves an empty local array and `unset/2` restores inheritance.\n`get/3` reads local values unless inheritance is requested. Commands are\n`t:tmux_command:t/0` values, rendered by `tmux_command:to_config/1` before tmux\nparses and stores them. A successful write confirms registration, while later\nhook effects need their own completion evidence.\n\nTable scope and execution context are separate. `run/2` selects a session,\nchecked window link or checked pane/link pair. Physical windows can belong to\nseveral sessions; a link preserves the chosen session and index. Preflight and\ndispatch are separate observations, with no atomic compare-and-act guarantee.\nKnown restarts and closed owners invalidate references. Captured rows never\nrefresh during these actions.\n\nNames and table scopes use the exact source-derived version catalogue from\n`tmux_option:catalogue/1`. User options, prefixes and aliases are rejected.\nThe native custom-event and monitor interfaces are outside this API. Deliberate\nraw integration remains available through `tmux_command:raw/2`. Calls perform\nI/O after validation and never retry uncertain mutations. The\n[hook guide](hooks.md) demonstrates registration and an effect acknowledgement."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook"},{"id":"tmux_hook:append/3","publicId":"tmux_hook:append/3","qualifiedName":"tmux_hook:append/3","name":"append/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"append(Scope, Name0, Commands)\n-spec append(scope(), binary(), commands()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":44,"end":49,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":53,"end":59,"target":"t:erlang:binary/0"},{"start":63,"end":71,"target":"t:tmux_hook:commands/0"},{"start":99,"end":123,"target":"t:tmux_operation:completed/0"},{"start":153,"end":175,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Commands","type":"commands()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_hook:commands/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Store commands at tmux's first vacant local index for the unindexed name. A new local array starts independently of inherited entries; this does not copy the parent's array. The command result does not report the chosen index; `get/3` observes current entries separately. Performs I/O with the parsing and unknown-outcome semantics of `set/3`."},"source":{"line":116,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-append-3"},{"id":"tmux_hook:clear/2","publicId":"tmux_hook:clear/2","qualifiedName":"tmux_hook:clear/2","name":"clear/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"clear(Scope, Name0)\n-spec clear(scope(), binary()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":32,"end":37,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":74,"end":98,"target":"t:tmux_operation:completed/0"},{"start":127,"end":149,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Leave an empty local hook array, masking inherited entries. This differs from `unset/2`, which restores inheritance. Global clear empties that defaults table. Performs I/O; existing effects already queued by tmux are not cancelled."},"source":{"line":132,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-clear-2"},{"id":"tmux_hook:get/3","publicId":"tmux_hook:get/3","qualifiedName":"tmux_hook:get/3","name":"get/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"get(Scope, Key, Options)\n-spec get(scope(),\n          tmux_option:key(),\n          tmux_option:read_options()) ->\n             {ok, value()} | none | {error, map()}.","references":[{"start":35,"end":40,"target":"t:tmux_hook:scope/0"},{"start":54,"end":69,"target":"t:tmux_option:key/0"},{"start":83,"end":107,"target":"t:tmux_option:read_options/0"},{"start":132,"end":137,"target":"t:tmux_hook:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":158,"end":161,"target":"t:erlang:map/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"tmux_option:key()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_option:key/0"}]},{"name":"Options","type":"tmux_option:read_options()","typeReferences":[{"start":0,"end":24,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, value()} | none | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_hook:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a builtin hook array or indexed entry. Options follow `t:tmux_option:read_options/0`: local-only by default, inherit = true follows its parent tables. Missing local arrays or entries return none; an empty local array returns {ok, #{}} and masks inheritance.","body":"Values are tmux's command-list serialization, including its quoting and escape\nsequences. They are neither the original input text nor individual decoded\narguments. Reading does not execute them. Use `set/3` for validated command\nvalues and `unset/2` to restore inheritance. Performs I/O and preserves backend\nerrors; a vanished target is not an absent hook."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-get-3"},{"id":"tmux_hook:run/2","publicId":"tmux_hook:run/2","qualifiedName":"tmux_hook:run/2","name":"run/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"run(Context, Name0)\n-spec run(context(), binary()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":30,"end":37,"target":"t:tmux_hook:context/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":72,"end":96,"target":"t:tmux_operation:completed/0"},{"start":123,"end":145,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Context","type":"context()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_hook:context/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request native set-hook -R in the explicit `t:context/0`. tmux resolves the hook through that context's effective tables; global table flags do not select a separate execution scope. A session uses its current window and pane. A window link fixes the observed session/index and expected physical window; a pane context additionally checks that pane's observed parent.","body":"Performs I/O. The result is the native command outcome, not an acknowledgement\nof background work launched by its commands. A missing or empty effective hook\ncan succeed without effects. Wait on an application completion condition when\neffects matter. Existence and membership checks precede dispatch. If the\ntarget disappears after preflight, tmux can still fall back to another\ncontext. This is not atomic compare-and-act. Use fresh links after known\ntopology changes."},"source":{"line":173,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-run-2"},{"id":"tmux_hook:set/3","publicId":"tmux_hook:set/3","qualifiedName":"tmux_hook:set/3","name":"set/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Commands)\n-spec set(scope(),\n          {binary(), non_neg_integer()},\n          commands()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":36,"end":41,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":56,"end":62,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"start":96,"end":104,"target":"t:tmux_hook:commands/0"},{"start":129,"end":153,"target":"t:tmux_operation:completed/0"},{"start":180,"end":202,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"{binary(), non_neg_integer()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":11,"end":26,"target":"t:erlang:non_neg_integer/0"}]},{"name":"Commands","type":"commands()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_hook:commands/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Replace one {Name, Index} entry with validated command values. An explicit index is required; other entries remain. Indexes range from zero to 2147483647. The rendered command text is bounded before dispatch. Native commands still interpret their arguments and formats when the hook later runs. Use `append/3` for native vacant-index selection and `clear/2` to mask inherited hooks with an empty local array.","body":"Performs I/O. tmux parses commands before replacing an existing entry, but a\nfailed first write can already create an empty local override. Registration\nand later execution are separate; this call promises no transaction, rollback\nor completion of future effects."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-set-3"},{"id":"tmux_hook:unset/2","publicId":"tmux_hook:unset/2","qualifiedName":"tmux_hook:unset/2","name":"unset/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"unset(Scope, Key)\n-spec unset(scope(), tmux_option:key()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":30,"end":35,"target":"t:tmux_hook:scope/0"},{"start":39,"end":54,"target":"t:tmux_option:key/0"},{"start":81,"end":105,"target":"t:tmux_operation:completed/0"},{"start":134,"end":156,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"tmux_option:key()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_option:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one indexed entry or the whole local array. Removing an entry leaves its local array, possibly empty. Removing the whole array restores inheritance; unsetting a global builtin resets its native default. Missing local values are a successful native no-op. Performs I/O; queued hook effects are unaffected."},"source":{"line":148,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_hook-unset-2"},{"id":"t:tmux_hook:commands/0","publicId":"t:tmux_hook:commands/0","qualifiedName":"tmux_hook:commands/0","name":"commands/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type commands() ::\n          tmux_command:t() | [tmux_command:t(), ...].","params":[],"references":[{"start":30,"end":44,"target":"t:tmux_command:t/0"},{"start":50,"end":64,"target":"t:tmux_command:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One validated command or a nonempty list; at most 256 commands and 32 KiB rendered text."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_hook-commands-0"},{"id":"t:tmux_hook:context/0","publicId":"t:tmux_hook:context/0","qualifiedName":"tmux_hook:context/0","name":"context/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type context() ::\n          tmux_model:session() |\n          tmux_model:window_link() |\n          {pane,\n           tmux_model:pane(),\n           tmux_model:window_link()}.","params":[],"references":[{"start":29,"end":47,"target":"t:tmux_model:session/0"},{"start":62,"end":84,"target":"t:tmux_model:window_link/0"},{"start":117,"end":132,"target":"t:tmux_model:pane/0"},{"start":147,"end":169,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A session's current context, one observed membership, or a pane in that membership."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_hook-context-0"},{"id":"t:tmux_hook:scope/0","publicId":"t:tmux_hook:scope/0","qualifiedName":"tmux_hook:scope/0","name":"scope/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope() ::\n          tmux_model:session() |\n          tmux_model:window() |\n          tmux_model:pane() |\n          {session_defaults | window_defaults,\n           tmux_server:t()}.","params":[],"references":[{"start":27,"end":45,"target":"t:tmux_model:session/0"},{"start":60,"end":77,"target":"t:tmux_model:window/0"},{"start":92,"end":107,"target":"t:tmux_model:pane/0"},{"start":170,"end":183,"target":"t:tmux_server:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A registered local table or explicit global session/window defaults; see `t:tmux_option:scope/0`."},"source":{"line":33,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_hook-scope-0"},{"id":"t:tmux_hook:value/0","publicId":"t:tmux_hook:value/0","qualifiedName":"tmux_hook:value/0","name":"value/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value() ::\n          binary() | #{non_neg_integer() => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":61,"end":67,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical native command-list text, or a sparse map of indexes to that text."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_hook-value-0"},{"id":"tmux_identity","publicId":"tmux_identity","qualifiedName":"tmux_identity","name":"tmux_identity","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Observe a Linux process incarnation using its PID, boot ID and start ticks.","body":"A successful check is an observation. It neither reserves a PID nor pins a\ntmux connection, and it never authorizes signalling a process. Endpoint owners\nin `m:tmux_server` compare the PID returned by the current connection as well.\nA server can still change between this check and a later one-shot command.\n\nUse `fingerprint/1` to compare captured incarnations across endpoint handles\nor persist that comparison in a plan. It performs no process observation;\nthe key grants neither liveness nor permission to act.","examples":[{"lang":"erlang","code":"1> Pid = list_to_integer(os:getpid()), ok.\nok\n2> {ok, Identity} = tmux_identity:observe(Pid), ok.\nok\n3> tmux_identity:check(Identity, Pid).\nok"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_identity"},{"id":"tmux_identity:check/2","publicId":"tmux_identity:check/2","qualifiedName":"tmux_identity:check/2","name":"check/2","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"check/2\n-spec check(t(), pos_integer()) -> ok | {error, map()}.","references":[{"start":20,"end":21,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":25,"end":36,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":56,"end":59,"target":"t:erlang:map/0"}],"params":[{"name":"Identity","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_identity:t/0"}]},{"name":"ObservedPid","type":"pos_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Re-observe the PID and compare its incarnation token. A successful result is a momentary observation, not ownership, permission to signal, or a same-connection guarantee."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_identity-check-2"},{"id":"tmux_identity:fingerprint/1","publicId":"tmux_identity:fingerprint/1","qualifiedName":"tmux_identity:fingerprint/1","name":"fingerprint/1","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"fingerprint/1\n-spec fingerprint(t()) ->\n                     {ok, fingerprint()} |\n                     {error, #{code := invalid_identity}}.","references":[{"start":32,"end":33,"target":"t:tmux_identity:t/0"},{"start":66,"end":77,"target":"t:tmux_identity:fingerprint/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_identity:t/0"}]}],"returns":"{ok, fingerprint()} |\n          {error, #{code := invalid_identity}}","returnsReferences":[{"start":5,"end":16,"target":"t:tmux_identity:fingerprint/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Derive a portable `t:fingerprint/0` from a captured identity without I/O.","body":"The key includes PID, boot ID and process-start ticks. Reconnecting to the same\nprocess preserves it; changing any component changes it. The encoding is\nversioned for persisted plans. Use `check/2` for a fresh process observation.\nMalformed identity terms return invalid_identity before hashing.","examples":[{"lang":"erlang","code":"1> {ok, I} = tmux_identity:observe(list_to_integer(os:getpid())), ok.\nok\n2> {ok, Key} = tmux_identity:fingerprint(I), ok.\nok\n3> byte_size(Key).\n73"}]},"source":{"line":59,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_identity-fingerprint-1"},{"id":"tmux_identity:observe/1","publicId":"tmux_identity:observe/1","qualifiedName":"tmux_identity:observe/1","name":"observe/1","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"observe/1\n-spec observe(pos_integer()) -> {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":24,"end":35,"target":"t:erlang:pos_integer/0"},{"start":47,"end":48,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Pid","type":"pos_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observe a Linux PID incarnation without signalling it. Returns a tagged error if the process cannot be identified; this performs local operating-system I/O."},"source":{"line":79,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_identity-observe-1"},{"id":"t:tmux_identity:fingerprint/0","publicId":"t:tmux_identity:fingerprint/0","qualifiedName":"tmux_identity:fingerprint/0","name":"fingerprint/0","namespace":"tmux_identity","parent":"tmux_identity","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type fingerprint() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":23,"end":29,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Versioned SHA-256 comparison key for a captured Linux process incarnation. The linux-v1 prefix identifies the canonical encoding, independent of Erlang term serialization. Keys compare identity observations, not endpoint ownership or current liveness. They are identifiers, not authentication tokens."},"source":{"line":38,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_identity-fingerprint-0"},{"id":"t:tmux_identity:t/0","publicId":"t:tmux_identity:t/0","qualifiedName":"tmux_identity:t/0","name":"t/0","namespace":"tmux_identity","parent":"tmux_identity","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observed Linux PID, boot identity and process-start token. It does not pin a connection."},"source":{"line":30,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_identity-t-0"},{"id":"tmux_json","publicId":"tmux_json","qualifiedName":"tmux_json","name":"tmux_json","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Decode bounded JSON using OTP's `m:json` parser and binary object keys.","body":"Documents are limited to 256 KiB before parsing and 32 nested containers\nduring parsing. Duplicate keys are rejected before overwriting values, even\nwhen different escapes spell the same key. Trailing input is rejected. Numbers\nstay in the shared exact integer range. Integral decimal tokens are converted\nexactly; fractional tokens that round to integers are rejected. Field\nvalidation decides whether a remaining float is permitted. Syntax and resource\nerrors have a root path; duplicate-key errors retain their complete document\npath. Use `tmux_filter:from_wire/2` to validate decoded filter data."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_json.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_json"},{"id":"tmux_json:decode/1","publicId":"tmux_json:decode/1","qualifiedName":"tmux_json:decode/1","name":"decode/1","namespace":"tmux_json","parent":"tmux_json","kind":"function","modifiers":[],"signatures":[{"raw":"decode/1\n-spec decode(binary()) ->\n                {ok, json:decode_value()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":22,"end":28,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":56,"end":73,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":87,"end":90,"target":"t:erlang:map/0"}],"params":[{"name":"Binary","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, json:decode_value()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":5,"end":22,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a decoded value or a structured error without creating payload atoms.","examples":[{"lang":"erlang","code":"1> tmux_json:decode(<<\"{\\\"a\\\": [1, true, null]}\">>).\n{ok,#{<<\"a\">> => [1,true,null]}}\n2> tmux_json:decode(<<\"{\\\"a\\\": {\\\"x\\\": 1, \\\"x\\\": 2}}\">>).\n{error,#{code => duplicate_key,path => [<<\"a\">>,<<\"x\">>]}}\n3> tmux_json:decode(<<\"[] []\">>).\n{error,#{code => trailing_input,path => []}}"}]},"source":{"line":32,"file":"apps/libtmux_erlang/src/tmux_json.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_json-decode-1"},{"id":"tmux_key","publicId":"tmux_key","qualifiedName":"tmux_key","name":"tmux_key","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Register and remove bindings in explicit server key tables.","body":"`bind/3` uses the native prefix table; `bind/4` chooses a table, repeat flag\nand note. Command values use `tmux_command:to_config/1` for the stored parser\nboundary. Replacing a binding resets its commands, repeat flag and note.\nRegistration does not prove that a client later executed the binding.\n\nTables belong to the server. A session's key-table option selects its default\ntable through `m:tmux_option`; tmux's prefix and client table-switching rules\nstill apply. Registering a custom table does not select it for any client.\n`clear_table/2` requires an explicit name and can affect attached clients.\n\n`listing/2` returns native presentation bytes. Field padding, quoting, note\ncoverage and formatting vary by daemon release. It does not decode bindings\nor promise reusable configuration. Retain the original command values when\nan application needs to install the same binding again.\n\nKey names use tmux's own binary spellings, such as C-b, Enter and MouseDown1Pane.\nThe daemon validates actual names and modifiers. Library validation bounds\nbytes and rejects NUL before dispatch. Calls use registered endpoint identity,\nperform explicit I/O and never retry uncertain mutations. They do not attach\na client or refresh captured rows.\n\nThe [key-table guide](keys.md) installs and removes an application-owned table."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key"},{"id":"tmux_key:bind/3","publicId":"tmux_key:bind/3","qualifiedName":"tmux_key:bind/3","name":"bind/3","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Key, Commands)\n-spec bind(tmux_server:t(),\n           key(),\n           tmux_command:t() | [tmux_command:t(), ...]) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":39,"end":52,"target":"t:tmux_server:t/0"},{"start":67,"end":70,"target":"t:tmux_key:key/0"},{"start":85,"end":99,"target":"t:tmux_command:t/0"},{"start":105,"end":119,"target":"t:tmux_command:t/0"},{"start":151,"end":175,"target":"t:tmux_operation:completed/0"},{"start":203,"end":225,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Commands","type":"tmux_command:t() | [tmux_command:t(), ...]","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"},{"start":20,"end":34,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Register commands in the native prefix table with default options. Performs I/O; see `bind/4` for replacement, command parsing and future execution."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-bind-3"},{"id":"tmux_key:bind/4","publicId":"tmux_key:bind/4","qualifiedName":"tmux_key:bind/4","name":"bind/4","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Key0, Commands, Options)\n-spec bind(tmux_server:t(),\n           key(),\n           tmux_command:t() | [tmux_command:t(), ...],\n           bind_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":49,"end":62,"target":"t:tmux_server:t/0"},{"start":77,"end":80,"target":"t:tmux_key:key/0"},{"start":95,"end":109,"target":"t:tmux_command:t/0"},{"start":115,"end":129,"target":"t:tmux_command:t/0"},{"start":150,"end":162,"target":"t:tmux_key:bind_options/0"},{"start":188,"end":212,"target":"t:tmux_operation:completed/0"},{"start":240,"end":262,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key0","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Commands","type":"tmux_command:t() | [tmux_command:t(), ...]","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"},{"start":20,"end":34,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"bind_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_key:bind_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Register or replace one binding with validated command values. Commands can be one value or a flat nonempty list; `tmux_command:to_config/1` applies the aggregate count and byte bounds. Options follow `t:bind_options/0`. Arguments, table names and notes are literal bytes at registration; stored commands still interpret their values and formats when a client executes them.","body":"Performs I/O. tmux parses the commands before replacing an existing binding.\nThe result confirms registration, while effects of future key presses need\ntheir own acknowledgement. Replacement resets the old repeat flag and note\nusing the supplied options. Errors preserve backend diagnostics and unknown\noutcomes; there is no rollback or automatic retry."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-bind-4"},{"id":"tmux_key:clear_table/2","publicId":"tmux_key:clear_table/2","qualifiedName":"tmux_key:clear_table/2","name":"clear_table/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"clear_table(Server, Table)\n-spec clear_table(tmux_server:t(), binary()) ->\n                     {ok, tmux_operation:completed()} |\n                     {error, tmux_operation:failure()}.","references":[{"start":45,"end":58,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":62,"end":68,"target":"t:erlang:binary/0"},{"start":101,"end":125,"target":"t:tmux_operation:completed/0"},{"start":160,"end":182,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Table","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove the entire explicitly named table through native unbind-key -a -T. Names use the bounds in `t:bind_options/0`. This can remove default bindings and affect attached clients. Missing tables remain native errors; this call does not restore factory defaults or cancel commands already queued. Performs I/O after endpoint and argument validation."},"source":{"line":114,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-clear_table-2"},{"id":"tmux_key:listing/1","publicId":"tmux_key:listing/1","qualifiedName":"tmux_key:listing/1","name":"listing/1","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"listing(Server)\n-spec listing(tmux_server:t()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":30,"end":43,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":72,"end":78,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read all tables as native listing bytes. Performs I/O; see `listing/2`."},"source":{"line":122,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-listing-1"},{"id":"tmux_key:listing/2","publicId":"tmux_key:listing/2","qualifiedName":"tmux_key:listing/2","name":"listing/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"listing/2\n-spec listing(tmux_server:t(), listing_options()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":24,"end":37,"target":"t:tmux_server:t/0"},{"start":41,"end":56,"target":"t:tmux_key:listing_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":85,"end":91,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":105,"end":108,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"listing_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_key:listing_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read native list-keys presentation output, optionally filtering by table and key through `t:listing_options/0`. Returns the command's stdout unchanged; spacing, quoting and included metadata follow that daemon. This is a text view, with no decoded-row, exact-note or configuration-round-trip guarantee.","body":"tmux 3.4 can escape dollar signs in this output. tmux 3.7c can send a single\nmatching entry to its status-message path, producing empty stdout without an\nattached target client. Empty presentation output does not prove absence.\nThe [key-table guide](keys.md) demonstrates a table with multiple bindings.\n\nThe baseline command has no custom format option on tmux 3.3. Deliberate\nnewer-server formatting is available through `tmux_command:raw/2`. Performs\nI/O; missing tables, invalid key spellings and backend errors remain errors."},"source":{"line":140,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-listing-2"},{"id":"tmux_key:unbind/2","publicId":"tmux_key:unbind/2","qualifiedName":"tmux_key:unbind/2","name":"unbind/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"unbind(Server, Key)\n-spec unbind(tmux_server:t(), key()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":33,"end":46,"target":"t:tmux_server:t/0"},{"start":50,"end":53,"target":"t:tmux_key:key/0"},{"start":81,"end":105,"target":"t:tmux_operation:completed/0"},{"start":135,"end":157,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove a binding from the native prefix table. Performs I/O; see `unbind/3`."},"source":{"line":83,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-unbind-2"},{"id":"tmux_key:unbind/3","publicId":"tmux_key:unbind/3","qualifiedName":"tmux_key:unbind/3","name":"unbind/3","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"unbind(Server, Key0, Options)\n-spec unbind(tmux_server:t(),\n             key(),\n             #{table => binary()}) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":43,"end":56,"target":"t:tmux_server:t/0"},{"start":73,"end":76,"target":"t:tmux_key:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":104,"end":110,"target":"t:erlang:binary/0"},{"start":139,"end":163,"target":"t:tmux_operation:completed/0"},{"start":193,"end":215,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key0","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Options","type":"#{table => binary()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":11,"end":17,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one key from the explicit table, defaulting to prefix. Only table is accepted in the options map. A missing key in an existing table is a native no-op; a missing explicit table remains an error. Removing the final custom binding can remove its table, so a repeated call can then report that missing table. Invalid native key names are never quietly suppressed.","body":"Performs I/O. Effects already queued by a client are unaffected. Use\n`clear_table/2` to remove an entire explicitly named table."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_key-unbind-3"},{"id":"t:tmux_key:bind_options/0","publicId":"t:tmux_key:bind_options/0","qualifiedName":"tmux_key:bind_options/0","name":"bind_options/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type bind_options() ::\n          #{table => binary(),\n            repeat => boolean(),\n            note => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":45,"end":51,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":77,"end":84,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":108,"end":114,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Default table is prefix and repeat is false. Tables contain 1..1024 NUL-free bytes. note is at most 32 KiB of NUL-free bytes; omitting it removes an old note when commands are replaced. Command-level aggregate bounds still apply."},"source":{"line":38,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_key-bind_options-0"},{"id":"t:tmux_key:key/0","publicId":"t:tmux_key:key/0","qualifiedName":"tmux_key:key/0","name":"key/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":15,"end":21,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A nonempty NUL-free native key spelling, at most 128 bytes; tmux validates its meaning."},"source":{"line":32,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_key-key-0"},{"id":"t:tmux_key:listing_options/0","publicId":"t:tmux_key:listing_options/0","qualifiedName":"tmux_key:listing_options/0","name":"listing_options/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type listing_options() ::\n          #{table => binary(), key => key()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":48,"end":54,"target":"t:erlang:binary/0"},{"start":65,"end":68,"target":"t:tmux_key:key/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"No table filter lists all native tables. table restricts the listing to one nonempty NUL-free name of at most 1024 bytes; key restricts it to a native key spelling. Missing tables and invalid key spellings retain native errors. Unmatched filters can return empty output or a backend error by release."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_key-listing_options-0"},{"id":"tmux_matcher","publicId":"tmux_matcher","qualifiedName":"tmux_matcher","name":"tmux_matcher","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Prepare a trusted local predicate once for a captured snapshot.","body":"Use `tmux_select:matching/2` with `{Module, State}`. The application chooses\nModule; external filter documents cannot select the `c:prepare/2`\ncallback. Preparation returns a unary Boolean function or a tagged error.\nCallback exceptions propagate. The adapter does not make executable predicates\nportable or push them to tmux."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_matcher.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_matcher"},{"id":"c:tmux_matcher:prepare/2","publicId":"c:tmux_matcher:prepare/2","qualifiedName":"tmux_matcher:prepare/2","name":"prepare/2","namespace":"tmux_matcher","parent":"tmux_matcher","kind":"function","modifiers":["abstract"],"signatures":[{"raw":"-callback prepare(State :: term(),\n                  Snapshot :: tmux_snapshot:t()) ->\n                     {ok,\n                      fun((tmux_model:row()) ->\n                              boolean())} |\n                     {error, term()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":27,"end":31,"target":"t:erlang:term/0"},{"start":65,"end":80,"target":"t:tmux_snapshot:t/0"},{"start":140,"end":154,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":191,"end":198,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":234,"end":238,"target":"t:erlang:term/0"}],"params":[{"name":"State","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, fun((tmux_model:row()) -> boolean())} |\n          {error, term()}","returnsReferences":[{"start":10,"end":24,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":31,"end":38,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":63,"end":67,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Prepare a local Boolean predicate once for this captured snapshot. Return a tagged preparation error when the matcher cannot operate. Callback exceptions remain application failures; this does not make a matcher portable or suitable for untrusted module selection."},"source":{"line":17,"file":"apps/libtmux_erlang/src/tmux_matcher.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"c-tmux_matcher-prepare-2"},{"id":"tmux_model","publicId":"tmux_model","qualifiedName":"tmux_model","name":"tmux_model","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Validated native domain records. Constructors perform no tmux I/O.","body":"Missing optional observations remain not_loaded; required identity fields\nmust be supplied. Unavailable capabilities remain\nunavailable. Neither state means an empty relation or known absence.\nRows created by `new/2` and the entity constructors are detached.\nEntity constructors accept generated input-map types such as\n`t:pane_input/0`. Use `new/2` to validate dynamic maps; Dialyzer checks\nknown constructor shapes but does not replace runtime validation.\nUse `tmux_server:bind/2` to register a fresh observed row for actions;\nuse `m:tmux_snapshot` for captured graph relationships.\n\nObserved rows carry a private `t:observation/0` value. Actions compare it\nwith the row's origin, snapshot identity and target fields, rejecting\nmismatched observations before I/O. Valid-shaped binding mismatches return\nobservation_mismatch; detached and malformed rows keep their validation\nerrors. Retarget through\n`tmux_server:bind/2`; it reads current values. This protects ordinary API\nuse, not authority against trusted code in the Erlang VM.\n\nNative model version 2 adds this association. Discard version-1 rows and\nsnapshots on upgrade and freshly observe them. `to_map/1` extracts domain\nfields for explicit schema validation; maps carry no actionable origin."},"source":{"line":2,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model"},{"id":"tmux_model:entity/1","publicId":"tmux_model:entity/1","qualifiedName":"tmux_model:entity/1","name":"entity/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"entity/1\n-spec entity(row()) -> tmux_schema:entity().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"start":32,"end":50,"target":"t:tmux_schema:entity/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"tmux_schema:entity()","returnsReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the built-in entity kind of a native row without I/O."},"source":{"line":233,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-entity-1"},{"id":"tmux_model:get/2","publicId":"tmux_model:get/2","qualifiedName":"tmux_model:get/2","name":"get/2","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"get/2\n-spec get(atom(), row()) -> term().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":16,"end":20,"target":"t:erlang:atom/0"},{"start":24,"end":27,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":34,"end":38,"target":"t:erlang:term/0"}],"params":[{"name":"Argument1","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Argument2","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"term()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a permitted domain field without I/O. Unknown fields raise unknown_field; unloaded and unavailable values remain distinct."},"source":{"line":268,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-get-2"},{"id":"tmux_model:model_version/1","publicId":"tmux_model:model_version/1","qualifiedName":"tmux_model:model_version/1","name":"model_version/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"model_version/1\n-spec model_version(row()) -> pos_integer().","references":[{"start":36,"end":39,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":46,"end":57,"target":"t:erlang:pos_integer/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"pos_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the native model version. Unknown versions fail validation; record internals are not a persistence format."},"source":{"line":254,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-model_version-1"},{"id":"tmux_model:new/2","publicId":"tmux_model:new/2","qualifiedName":"tmux_model:new/2","name":"new/2","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"new(Entity, Fields)\n-spec new(atom(), map()) ->\n             {ok, row()} |\n             {error, tmux_schema:error_detail()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":30,"end":34,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"start":66,"end":69,"target":"t:tmux_model:row/0"},{"start":96,"end":120,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Fields","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"returns":"{ok, row()} | {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":8,"target":"t:tmux_model:row/0"},{"start":22,"end":46,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached row from validated observations.","body":"Accepts dynamic maps, including malformed input that returns a tagged\n`t:tmux_schema:error_detail/0`. For trusted typed code, prefer the entity\nconstructors such as `pane/1` and `t:pane_input/0`.","examples":[{"lang":"erlang","code":"1> {ok, Pane} = tmux_model:new(pane, #{id => <<\"%1\">>, width => 120}), ok.\nok\n2> tmux_model:get(width, Pane).\n120"}]},"source":{"line":192,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-new-2"},{"id":"tmux_model:origin/1","publicId":"tmux_model:origin/1","qualifiedName":"tmux_model:origin/1","name":"origin/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"origin/1\n-spec origin(row()) -> none | reference().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":39,"end":48,"target":"t:erlang:reference/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"none | reference()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":7,"end":16,"target":"t:erlang:reference/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the opaque origin token, or none for a detached row. This does not revalidate endpoint lifetime."},"source":{"line":240,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-origin-1"},{"id":"tmux_model:pane/1","publicId":"tmux_model:pane/1","qualifiedName":"tmux_model:pane/1","name":"pane/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"pane(Fields)\n-spec pane(pane_input()) ->\n              {ok, pane()} |\n              {error, tmux_schema:error_detail()}.","references":[{"start":24,"end":34,"target":"t:tmux_model:pane_input/0"},{"start":60,"end":64,"target":"t:tmux_model:pane/0"},{"start":92,"end":116,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"pane_input()","typeReferences":[{"start":0,"end":10,"target":"t:tmux_model:pane_input/0"}]}],"returns":"{ok, pane()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":9,"target":"t:tmux_model:pane/0"},{"start":33,"end":57,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached pane row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":212,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-pane-1"},{"id":"tmux_model:session/1","publicId":"tmux_model:session/1","qualifiedName":"tmux_model:session/1","name":"session/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"session(Fields)\n-spec session(session_input()) ->\n                 {ok, session()} |\n                 {error, tmux_schema:error_detail()}.","references":[{"start":30,"end":43,"target":"t:tmux_model:session_input/0"},{"start":72,"end":79,"target":"t:tmux_model:session/0"},{"start":110,"end":134,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"session_input()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_model:session_input/0"}]}],"returns":"{ok, session()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":12,"target":"t:tmux_model:session/0"},{"start":36,"end":60,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached session row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":200,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-session-1"},{"id":"tmux_model:snapshot_id/1","publicId":"tmux_model:snapshot_id/1","qualifiedName":"tmux_model:snapshot_id/1","name":"snapshot_id/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot_id/1\n-spec snapshot_id(row()) -> none | reference().","references":[{"start":32,"end":35,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":49,"end":58,"target":"t:erlang:reference/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"none | reference()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":7,"end":16,"target":"t:erlang:reference/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the capture identity, or none when not associated with a snapshot. Performs no I/O."},"source":{"line":247,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-snapshot_id-1"},{"id":"tmux_model:to_map/1","publicId":"tmux_model:to_map/1","qualifiedName":"tmux_model:to_map/1","name":"to_map/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"to_map/1\n-spec to_map(row()) -> map().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"map()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return domain field values without origin or capture metadata. This is not the portable filter wire representation. Performs no I/O."},"source":{"line":261,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-to_map-1"},{"id":"tmux_model:validate/1","publicId":"tmux_model:validate/1","qualifiedName":"tmux_model:validate/1","name":"validate/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"validate(Row)\n-spec validate(term()) -> {ok, row()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":29,"end":33,"target":"t:erlang:term/0"},{"start":45,"end":48,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, row()} | {error, map()}","returnsReferences":[{"start":5,"end":8,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate native row shape, model version and normalized observations. Exported records do not enforce these invariants at construction. Performs no I/O."},"source":{"line":216,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-validate-1"},{"id":"tmux_model:window/1","publicId":"tmux_model:window/1","qualifiedName":"tmux_model:window/1","name":"window/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"window(Fields)\n-spec window(window_input()) ->\n                {ok, window()} |\n                {error, tmux_schema:error_detail()}.","references":[{"start":28,"end":40,"target":"t:tmux_model:window_input/0"},{"start":68,"end":74,"target":"t:tmux_model:window/0"},{"start":104,"end":128,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"window_input()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_model:window_input/0"}]}],"returns":"{ok, window()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":11,"target":"t:tmux_model:window/0"},{"start":35,"end":59,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached window row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":204,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-window-1"},{"id":"tmux_model:window_link/1","publicId":"tmux_model:window_link/1","qualifiedName":"tmux_model:window_link/1","name":"window_link/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"window_link(Fields)\n-spec window_link(window_link_input()) ->\n                     {ok, window_link()} |\n                     {error, tmux_schema:error_detail()}.","references":[{"start":38,"end":55,"target":"t:tmux_model:window_link_input/0"},{"start":88,"end":99,"target":"t:tmux_model:window_link/0"},{"start":134,"end":158,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"window_link_input()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window_link_input/0"}]}],"returns":"{ok, window_link()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":16,"target":"t:tmux_model:window_link/0"},{"start":40,"end":64,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached window_link row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":208,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-window_link-1"},{"id":"t:tmux_model:observation/0","publicId":"t:tmux_model:observation/0","qualifiedName":"tmux_model:observation/0","name":"observation/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque observation().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Private captured target association, created by observation. Retain with its row; construction and field access are internal. It is not an authorization or serialization format."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-observation-0"},{"id":"t:tmux_model:pane/0","publicId":"t:tmux_model:pane/0","qualifiedName":"tmux_model:pane/0","name":"pane/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pane() :: #pane{}.","params":[],"references":[{"start":16,"end":21,"target":"#tmux_model:pane{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated pane observation. Native records are experimental in OTP 29."},"source":{"line":112,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-pane-0"},{"id":"t:tmux_model:pane_id/0","publicId":"t:tmux_model:pane_id/0","qualifiedName":"tmux_model:pane_id/0","name":"pane_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal pane_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":22,"end":28,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical pane ID binary in the percent namespace; nominal checking is by Dialyzer."},"source":{"line":37,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-pane_id-0"},{"id":"t:tmux_model:pane_input/0","publicId":"t:tmux_model:pane_input/0","qualifiedName":"tmux_model:pane_input/0","name":"pane_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pane_input() ::\n          #{id := pane_id(),\n            window_id =>\n                window_id() | not_loaded | unavailable,\n            index =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            active => boolean() | not_loaded | unavailable,\n            current_command =>\n                binary() | not_loaded | unavailable,\n            current_path =>\n                binary() | not_loaded | unavailable,\n            width =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            height =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            pid =>\n                pos_integer() |\n                float() |\n                none | not_loaded | unavailable,\n            title => binary() | not_loaded | unavailable,\n            dead => boolean() | not_loaded | unavailable,\n            exit_status =>\n                integer() |\n                float() |\n                none | not_loaded | unavailable}.","params":[],"references":[{"start":40,"end":47,"target":"t:tmux_model:pane_id/0"},{"start":92,"end":101,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":169,"end":184,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":205,"end":210,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":279,"end":286,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":364,"end":370,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":445,"end":451,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":519,"end":534,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":555,"end":560,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":645,"end":660,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":681,"end":686,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":768,"end":779,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":800,"end":805,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":880,"end":886,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":937,"end":944,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":1018,"end":1025,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":1046,"end":1051,"target":"t:erlang:float/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `pane/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":162,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-pane_input-0"},{"id":"t:tmux_model:row/0","publicId":"t:tmux_model:row/0","qualifiedName":"tmux_model:row/0","name":"row/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type row() ::\n          #session{} | #window{} | #window_link{} | #pane{}.","params":[],"references":[{"start":25,"end":33,"target":"#tmux_model:session{}"},{"start":38,"end":45,"target":"#tmux_model:window{}"},{"start":50,"end":62,"target":"#tmux_model:window_link{}"},{"start":67,"end":72,"target":"#tmux_model:pane{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One schema-defined native domain record, with separate origin and capture metadata."},"source":{"line":104,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-row-0"},{"id":"t:tmux_model:session/0","publicId":"t:tmux_model:session/0","qualifiedName":"tmux_model:session/0","name":"session/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type session() :: #session{}.","params":[],"references":[{"start":19,"end":27,"target":"#tmux_model:session{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated session observation. Native records are experimental in OTP 29."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-session-0"},{"id":"t:tmux_model:session_id/0","publicId":"t:tmux_model:session_id/0","qualifiedName":"tmux_model:session_id/0","name":"session_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal session_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":25,"end":31,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical session ID binary in the dollar namespace."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-session_id-0"},{"id":"t:tmux_model:session_input/0","publicId":"t:tmux_model:session_input/0","qualifiedName":"tmux_model:session_input/0","name":"session_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type session_input() ::\n          #{id := session_id(),\n            name => binary() | not_loaded | unavailable,\n            attached_count =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            attached =>\n                boolean() | not_loaded | unavailable,\n            created =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable}.","params":[],"references":[{"start":43,"end":53,"target":"t:tmux_model:session_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":77,"end":83,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":160,"end":175,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":196,"end":201,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":288,"end":295,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":365,"end":380,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":401,"end":406,"target":"t:erlang:float/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `session/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":120,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-session_input-0"},{"id":"t:tmux_model:window/0","publicId":"t:tmux_model:window/0","qualifiedName":"tmux_model:window/0","name":"window/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window() :: #window{}.","params":[],"references":[{"start":18,"end":25,"target":"#tmux_model:window{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated window observation. Native records are experimental in OTP 29."},"source":{"line":108,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-window-0"},{"id":"t:tmux_model:window_id/0","publicId":"t:tmux_model:window_id/0","qualifiedName":"tmux_model:window_id/0","name":"window_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal window_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":24,"end":30,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical physical-window ID binary in the at-sign namespace."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-window_id-0"},{"id":"t:tmux_model:window_input/0","publicId":"t:tmux_model:window_input/0","qualifiedName":"tmux_model:window_input/0","name":"window_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_input() ::\n          #{id := window_id(),\n            name => binary() | not_loaded | unavailable,\n            width =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            height =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            pane_count =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            layout => binary() | not_loaded | unavailable}.","params":[],"references":[{"start":42,"end":51,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":149,"end":164,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":185,"end":190,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":275,"end":290,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":311,"end":316,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":405,"end":420,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":441,"end":446,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":515,"end":521,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `window/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":134,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-window_input-0"},{"id":"t:tmux_model:window_link/0","publicId":"t:tmux_model:window_link/0","qualifiedName":"tmux_model:window_link/0","name":"window_link/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_link() :: #window_link{}.","params":[],"references":[{"start":23,"end":35,"target":"#tmux_model:window_link{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated window_link observation. Native records are experimental in OTP 29."},"source":{"line":110,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-window_link-0"},{"id":"t:tmux_model:window_link_input/0","publicId":"t:tmux_model:window_link_input/0","qualifiedName":"tmux_model:window_link_input/0","name":"window_link_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_link_input() ::\n          #{session_id := session_id(),\n            window_id := window_id(),\n            index := non_neg_integer() | float(),\n            active => boolean() | not_loaded | unavailable}.","params":[],"references":[{"start":55,"end":65,"target":"t:tmux_model:session_id/0"},{"start":94,"end":103,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":128,"end":143,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":148,"end":153,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":179,"end":186,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `window_link/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_model-window_link_input-0"},{"id":"#tmux_model:session{}","publicId":"#tmux_model:session{}","qualifiedName":"#tmux_model:session{}","name":"#session{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #session{id :: session_id(),\n                 name =\n                     not_loaded ::\n                         binary() |\n                         not_loaded | unavailable,\n                 attached_count =\n                     not_loaded ::\n                         non_neg_integer() |\n                         not_loaded | unavailable,\n                 attached =\n                     not_loaded ::\n                         boolean() |\n                         not_loaded | unavailable,\n                 created =\n                     not_loaded ::\n                         non_neg_integer() |\n                         not_loaded | unavailable,\n                 origin = none :: none | reference(),\n                 snapshot_id = none :: none | reference(),\n                 model_version = 2 :: pos_integer(),\n                 observation =\n                     none :: none | observation()}.","params":[],"references":[{"start":23,"end":33,"target":"t:tmux_model:session_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":121,"end":127,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":277,"end":292,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":436,"end":443,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":586,"end":601,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":698,"end":707,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":757,"end":766,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":808,"end":819,"target":"t:erlang:pos_integer/0"},{"start":890,"end":901,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-session"},{"id":"#tmux_model:window{}","publicId":"#tmux_model:window{}","qualifiedName":"#tmux_model:window{}","name":"#window{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #window{id :: window_id(),\n                name =\n                    not_loaded ::\n                        binary() | not_loaded | unavailable,\n                width =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                height =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                pane_count =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                layout =\n                    not_loaded ::\n                        binary() | not_loaded | unavailable,\n                origin = none :: none | reference(),\n                snapshot_id = none :: none | reference(),\n                model_version = 2 :: pos_integer(),\n                observation = none :: none | observation()}.","params":[],"references":[{"start":22,"end":31,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":116,"end":122,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":235,"end":250,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":388,"end":403,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":545,"end":560,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":698,"end":704,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":775,"end":784,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":833,"end":842,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":883,"end":894,"target":"t:erlang:pos_integer/0"},{"start":943,"end":954,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":60,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-window"},{"id":"#tmux_model:window_link{}","publicId":"#tmux_model:window_link{}","qualifiedName":"#tmux_model:window_link{}","name":"#window_link{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #window_link{session_id :: session_id(),\n                     window_id :: window_id(),\n                     index :: non_neg_integer(),\n                     active =\n                         not_loaded ::\n                             boolean() |\n                             not_loaded | unavailable,\n                     origin = none :: none | reference(),\n                     snapshot_id =\n                         none :: none | reference(),\n                     model_version = 2 :: pos_integer(),\n                     observation =\n                         none :: none | observation()}.","params":[],"references":[{"start":35,"end":45,"target":"t:tmux_model:session_id/0"},{"start":83,"end":92,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":126,"end":141,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":243,"end":250,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":355,"end":364,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":443,"end":452,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":498,"end":509,"target":"t:erlang:pos_integer/0"},{"start":588,"end":599,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-window_link"},{"id":"#tmux_model:pane{}","publicId":"#tmux_model:pane{}","qualifiedName":"#tmux_model:pane{}","name":"#pane{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #pane{id :: pane_id(),\n              window_id =\n                  not_loaded ::\n                      window_id() |\n                      not_loaded | unavailable,\n              index =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              active =\n                  not_loaded ::\n                      boolean() | not_loaded | unavailable,\n              current_command =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              current_path =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              width =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              height =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              pid =\n                  not_loaded ::\n                      pos_integer() |\n                      none | not_loaded | unavailable,\n              title =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              dead =\n                  not_loaded ::\n                      boolean() | not_loaded | unavailable,\n              exit_status =\n                  not_loaded ::\n                      integer() |\n                      none | not_loaded | unavailable,\n              origin = none :: none | reference(),\n              snapshot_id = none :: none | reference(),\n              model_version = 2 :: pos_integer(),\n              observation = none :: none | observation()}.","params":[],"references":[{"start":20,"end":27,"target":"t:tmux_model:pane_id/0"},{"start":111,"end":120,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":249,"end":264,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":394,"end":401,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":518,"end":524,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":638,"end":644,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":751,"end":766,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":896,"end":911,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":1038,"end":1049,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1185,"end":1191,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":1297,"end":1304,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":1417,"end":1424,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":1522,"end":1531,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":1578,"end":1587,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":1626,"end":1637,"target":"t:erlang:pos_integer/0"},{"start":1684,"end":1695,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":84,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_model-pane"},{"id":"tmux_operation","publicId":"tmux_operation","qualifiedName":"tmux_operation","name":"tmux_operation","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Own a command independently of an individual wait.","body":"`start/3` submits a validated command through the endpoint's\nbounded admission. The initiating process owns it. `await/2`\ntiming out abandons only that wait; `cancel/1` or owner death\nretires the client and may leave an unknown tmux outcome. The endpoint\nacknowledges `transfer/2` after monitoring the new owner and\nbefore replying to the old owner. The new process does not perform a\nhandshake. Retired results expire after 60 seconds or earlier when the\nendpoint exceeds 64 retained results or 4 MiB of retained stdout/stderr\n(oldest evicted first). Closing the endpoint clears its operation results\nimmediately. Each operation accepts at most 16 concurrent waiters; excess\nwaits return too_many_waiters. `await_started/2` returns\nlifecycle status once the operation leaves queued; dispatch authorization does\nnot establish a tmux aftereffect.\n\nSee `t:completed/0` and `t:failure/0` for\ncommand outcomes and `t:state/0` for lifecycle status. The [job\nguide](jobs.md) shows the complete workflow. Bounded OTP Logger reports\ncorrelate outcomes by operation and endpoint generation; see\n[runtime diagnostics](diagnostics.md) for levels, fields and data boundaries."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation"},{"id":"tmux_operation:await/2","publicId":"tmux_operation:await/2","qualifiedName":"tmux_operation:await/2","name":"await/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"await(Operation, Timeout)\n-spec await(t(), timeout()) ->\n               {ok, completed()} | {error, failure()}.","references":[{"start":38,"end":39,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":43,"end":50,"target":"t:erlang:timeout/0"},{"start":77,"end":86,"target":"t:tmux_operation:completed/0"},{"start":100,"end":107,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Timeout","type":"timeout()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:timeout/0"}]}],"returns":"{ok, completed()} | {error, failure()}","returnsReferences":[{"start":5,"end":14,"target":"t:tmux_operation:completed/0"},{"start":28,"end":35,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Wait for a retained result for at most Timeout. An await_timeout removes only this waiter; the operation continues and its handle remains usable. Additional waiters do not become owners. Results preserve outcome and cleanup certainty."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-await-2"},{"id":"tmux_operation:await_started/2","publicId":"tmux_operation:await_started/2","qualifiedName":"tmux_operation:await_started/2","name":"await_started/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"await_started(Operation, Timeout)\n-spec await_started(t(), timeout()) ->\n                       {ok, state()} | {error, failure()}.","references":[{"start":54,"end":55,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":59,"end":66,"target":"t:erlang:timeout/0"},{"start":101,"end":106,"target":"t:tmux_operation:state/0"},{"start":120,"end":127,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Timeout","type":"timeout()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:timeout/0"}]}],"returns":"{ok, state()} | {error, failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_operation:state/0"},{"start":24,"end":31,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Wait until the operation leaves queued, returning its lifecycle state even if it has already failed or retired. Inspect outcome and cleanup; call `await/2` for final command data. Authorization is not proof of a tmux aftereffect. A timeout abandons this wait without cancelling the operation."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-await_started-2"},{"id":"tmux_operation:cancel/1","publicId":"tmux_operation:cancel/1","qualifiedName":"tmux_operation:cancel/1","name":"cancel/1","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"cancel(Operation)\n-spec cancel(t()) ->\n                {ok,\n                 cancelled_before_send | cancel_requested |\n                 already_completed} |\n                {error, map()}.","references":[{"start":31,"end":32,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":182,"end":185,"target":"t:erlang:map/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]}],"returns":"{ok,\n           cancelled_before_send | cancel_requested |\n           already_completed} |\n          {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":109,"end":112,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request cancellation using this handle. Any holder can cancel; only the owner can transfer ownership. Queued work can be cancelled before submission; possibly sent work retires its client and can retain an unknown tmux outcome. Use `await/2` for the result and cleanup proof. Never infer rollback or automatically retry a mutation from cancellation alone. already_completed means a response exists; it does not establish complete cleanup."},"source":{"line":117,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-cancel-1"},{"id":"tmux_operation:start/3","publicId":"tmux_operation:start/3","qualifiedName":"tmux_operation:start/3","name":"start/3","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"start(Server, Command, Options)\n-spec start(tmux_server:t(),\n            tmux_command:t(),\n            tmux_server:command_options()) ->\n               {ok, t()} | {error, failure()}.","references":[{"start":44,"end":57,"target":"t:tmux_server:t/0"},{"start":73,"end":87,"target":"t:tmux_command:t/0"},{"start":103,"end":130,"target":"t:tmux_server:command_options/0"},{"start":157,"end":158,"target":"t:tmux_operation:t/0"},{"start":172,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Command","type":"tmux_command:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"tmux_server:command_options()","typeReferences":[{"start":0,"end":27,"target":"t:tmux_server:command_options/0"}]}],"returns":"{ok, t()} | {error, failure()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_operation:t/0"},{"start":20,"end":27,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Submit a validated command under the endpoint's admission limits and return an operation handle. The initiating process owns it. Submission is non-blocking with respect to command completion; the handle does not prove that tmux has executed the command."},"source":{"line":77,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-start-3"},{"id":"tmux_operation:status/1","publicId":"tmux_operation:status/1","qualifiedName":"tmux_operation:status/1","name":"status/1","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"status(Operation)\n-spec status(t()) -> {ok, state()} | {error, failure()}.","references":[{"start":31,"end":32,"target":"t:tmux_operation:t/0"},{"start":44,"end":49,"target":"t:tmux_operation:state/0"},{"start":63,"end":70,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]}],"returns":"{ok, state()} | {error, failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_operation:state/0"},{"start":24,"end":31,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the retained lifecycle state without starting a tmux command. Expired handles return operation_expired. Status is observation of the operation, not evidence that a possibly sent mutation was cancelled."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-status-1"},{"id":"tmux_operation:transfer/2","publicId":"tmux_operation:transfer/2","qualifiedName":"tmux_operation:transfer/2","name":"transfer/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"transfer/2\n-spec transfer(t(), pid()) -> ok | {error, map()}.","references":[{"start":26,"end":27,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":54,"end":57,"target":"t:erlang:map/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Owner","type":"pid()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:pid/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Transfer ownership to a live process on this Erlang node. The endpoint installs its new owner monitor before releasing the previous monitor and returns after the swap. The new process performs no handshake. Waiters and ownership remain separate; endpoint ownership does not change.","body":"An `await_timeout` abandons the reply, not the queued ownership change. The\ntransfer may complete later. Use `status/1` to read the current owner before\nrelying on ownership; a timeout does not prove that the old owner remains."},"source":{"line":130,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_operation-transfer-2"},{"id":"t:tmux_operation:cleanup/0","publicId":"t:tmux_operation:cleanup/0","qualifiedName":"tmux_operation:cleanup/0","name":"cleanup/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type cleanup() :: complete | incomplete | unverified.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"complete proves owned client retirement; incomplete or unverified does not."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-cleanup-0"},{"id":"t:tmux_operation:completed/0","publicId":"t:tmux_operation:completed/0","qualifiedName":"tmux_operation:completed/0","name":"completed/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type completed() ::\n          #{stdout := binary(),\n            stderr := binary(),\n            exit_status := 0,\n            stdin_delivered := non_neg_integer(),\n            outcome := success,\n            cleanup := complete}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":146,"end":161,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A successful command result. stdout and stderr are separate byte strings; exit_status is zero. stdin_delivered counts bytes accepted by the client pipe, not bytes consumed by tmux. success does not prove a background aftereffect."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-completed-0"},{"id":"t:tmux_operation:failure/0","publicId":"t:tmux_operation:failure/0","qualifiedName":"tmux_operation:failure/0","name":"failure/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type failure() ::\n          #{code := atom(),\n            outcome => outcome(),\n            cleanup => cleanup(),\n            stdout => binary(),\n            stderr => binary(),\n            stdin_delivered => non_neg_integer(),\n            exit_status => integer(),\n            submitted => boolean(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":39,"end":43,"target":"t:erlang:atom/0"},{"start":70,"end":77,"target":"t:tmux_operation:outcome/0"},{"start":104,"end":111,"target":"t:tmux_operation:cleanup/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":137,"end":143,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":169,"end":175,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":210,"end":225,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":256,"end":263,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":292,"end":299,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":315,"end":319,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":325,"end":329,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A tagged error detail with a stable code and optional certainty/output data. Validation, admission and wait errors may contain only code. Command failures retain available stdout/stderr, stdin_delivered and exit_status. Other keys provide code-specific context. Never infer missing certainty fields.","body":"Common codes are busy, invalid_operation_options, command_error, deadline,\ncancelled, stale_server, cleanup_incomplete, await_timeout and\noperation_expired. command_error means a nonzero client exit; it does not roll\nback a mutation. await_timeout abandons only this wait. operation_expired\ncannot reconstruct a previous result or establish its remote outcome."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-failure-0"},{"id":"t:tmux_operation:outcome/0","publicId":"t:tmux_operation:outcome/0","qualifiedName":"tmux_operation:outcome/0","name":"outcome/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type outcome() ::\n          success | error | not_started |\n          cancelled_before_send | unknown.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Command certainty, separate from resource cleanup. unknown must not trigger an automatic mutation retry."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-outcome-0"},{"id":"t:tmux_operation:state/0","publicId":"t:tmux_operation:state/0","qualifiedName":"tmux_operation:state/0","name":"state/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := queued | sent | responded | retired,\n            stage :=\n                pending | waiting | preflight | command,\n            owner := pid(),\n            outcome := pending | outcome(),\n            cleanup := pending | cleanup()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":174,"end":177,"target":"t:erlang:pid/0"},{"start":214,"end":221,"target":"t:tmux_operation:outcome/0"},{"start":258,"end":265,"target":"t:tmux_operation:cleanup/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observed lifecycle state, without command output. queued includes admission and identity preflight; sent means dispatch authorization, not a proven aftereffect. responded can retain incomplete cleanup; retired releases operation resources. pending certainty means no result yet. The owner is the initiating or transferred process; holding a waiter handle does not change it."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-state-0"},{"id":"t:tmux_operation:t/0","publicId":"t:tmux_operation:t/0","qualifiedName":"tmux_operation:t/0","name":"t/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A generation-bound operation handle. Possessing a waiter handle does not transfer ownership."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_operation-t-0"},{"id":"tmux_option","publicId":"tmux_option","qualifiedName":"tmux_option","name":"tmux_option","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Read and change explicit tmux option tables through registered references.","body":"Session, physical window and pane records from `m:tmux_model` select their\nlocal tables. Global tables use {server, Server}, {session_defaults, Server}\nor {window_defaults, Server}. Built-in canonical names and scopes are checked\nagainst pinned source metadata; tmux otherwise lets a name override the\nsupplied scope flags. `m:tmux_hook` owns hook registration and execution;\nhooks are rejected here. Prefixes and aliases are rejected.\n\n`get/3` requires an explicit options map. Local-only reads are the\ndefault; inherit = true follows tmux's table parents (pane -> window -> window\ndefaults, or session -> session defaults). Server options have no parent. A\nmissing local value or array entry returns none; an empty binary or empty\narray is a value. Arrays return maps of indexes to binary values, preserving\nsparse indexes. There is no hidden capture refresh or cache of option values.\n`get_many/3` reads the same scalar key from up to seven local rows through one\nbounded native sequence, retaining local-only semantics by default.\n\nValues are NUL-free binary tmux text bytes, including non-UTF-8 bytes. No\nshell or format expansion is applied by this API. tmux still interprets a\nbuilt-in option according to its type: formats, shell commands and command\noptions may execute later when tmux uses them. This API is for trusted\napplication code. Numeric and flag values are canonical binary text on reads,\nnot Erlang numbers.\n\nBuilt-in metadata covers every released version in the supported tmux\n3.3a–3.8 range, including exact patch letters. Tracking and unknown versions\nfail closed. User options beginning @ do not need a built-in\ncatalogue. The raw `tmux_command:raw/2` remains available for deliberate\nnewer-server integration. All mutations are one-shot I/O with observed\nidentity checks, not transactions. Timeouts can leave an unknown remote\noutcome; mutations are never retried here. See the [scoped options\nguide](options.md) for ownership and inheritance."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option"},{"id":"tmux_option:catalogue/1","publicId":"tmux_option:catalogue/1","qualifiedName":"tmux_option:catalogue/1","name":"catalogue/1","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"catalogue(Version)\n-spec catalogue(tmux_version:t()) ->\n                   {ok, #{binary() => metadata()}} |\n                   {error, map()}.","references":[{"start":35,"end":49,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":82,"end":88,"target":"t:erlang:binary/0"},{"start":94,"end":102,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":136,"end":139,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"{ok, #{binary() => metadata()}} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":7,"end":13,"target":"t:erlang:binary/0"},{"start":19,"end":27,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":42,"end":45,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return all canonical built-in option and hook metadata for one exact parsed version, without I/O. Catalogues cover every release from 3.3a through 3.8; historical 3.3 metadata remains available for source discovery. The generated reference records each release's source commit and file digests."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-catalogue-1"},{"id":"tmux_option:describe/2","publicId":"tmux_option:describe/2","qualifiedName":"tmux_option:describe/2","name":"describe/2","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"describe(Version, Name)\n-spec describe(tmux_version:t(), binary()) ->\n                  {ok, metadata()} | {error, map()}.","references":[{"start":39,"end":53,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":57,"end":63,"target":"t:erlang:binary/0"},{"start":93,"end":101,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":115,"end":118,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, metadata()} | {error, map()}","returnsReferences":[{"start":5,"end":13,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return source metadata for a canonical built-in name and a parsed daemon version, without I/O. Unknown names, unavailable names, tracking builds and uncatalogued versions have distinct errors. The catalogue describes scopes and parser types; it does not qualify runtime behavior or authorize hook execution.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3a\">>), ok.\nok\n2> {ok, M} = tmux_option:describe(V, <<\"exit-empty\">>), ok.\nok\n3> maps:get(scopes, M).\n[server]"}]},"source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-describe-2"},{"id":"tmux_option:get/3","publicId":"tmux_option:get/3","qualifiedName":"tmux_option:get/3","name":"get/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"get(Scope, Key, Options)\n-spec get(scope(), key(), read_options()) ->\n             {ok, value()} | none | {error, map()}.","references":[{"start":35,"end":40,"target":"t:tmux_option:scope/0"},{"start":44,"end":47,"target":"t:tmux_option:key/0"},{"start":51,"end":63,"target":"t:tmux_option:read_options/0"},{"start":88,"end":93,"target":"t:tmux_option:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":114,"end":117,"target":"t:erlang:map/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, value()} | none | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_option:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read one option or array, performing I/O after validation. Missing local values and array entries return none; known empty strings and arrays return {ok, Value}. inherit = true reads through tmux's parent tables. Unknown fields are rejected. Errors retain backend diagnostics; a missing target never becomes absence. Use `set/4` to write a value and `unset/2` to restore inheritance."},"source":{"line":105,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-get-3"},{"id":"tmux_option:get_many/3","publicId":"tmux_option:get_many/3","qualifiedName":"tmux_option:get_many/3","name":"get_many/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"get_many(Scopes, Name, Options)\n-spec get_many([tmux_model:session() |\n                tmux_model:window() |\n                tmux_model:pane(),\n                ...],\n               binary(),\n               read_options()) ->\n                  {ok, [binary() | none]} | {error, map()}.","references":[{"start":48,"end":66,"target":"t:tmux_model:session/0"},{"start":87,"end":104,"target":"t:tmux_model:window/0"},{"start":125,"end":140,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":181,"end":187,"target":"t:erlang:binary/0"},{"start":206,"end":218,"target":"t:tmux_option:read_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":249,"end":255,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":277,"end":280,"target":"t:erlang:map/0"}],"params":[{"name":"Scopes","type":"[tmux_model:session() |\n           tmux_model:window() |\n           tmux_model:pane(),\n           ...]","typeReferences":[{"start":1,"end":19,"target":"t:tmux_model:session/0"},{"start":35,"end":52,"target":"t:tmux_model:window/0"},{"start":68,"end":83,"target":"t:tmux_model:pane/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, [binary() | none]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read one scalar option from one to seven local rows on the same registered endpoint. Performs one bounded native sequence after validating every scope. Results follow input order; each entry is binary text or none for a missing local value. `t:read_options/0` controls inheritance as in `get/3`.","body":"Names use ASCII letters, digits, dots, underscores and hyphens, with an\noptional leading @ for user options. Global tables, arrays, indexed keys,\nhooks and command options are unsupported. Use `get/3` for broader option\nreads and `tmux_hook:get/3` for hooks.\nInvalid scopes, unsupported keys and different owners fail before dispatch.\n\nEach read is bracketed by matching native target-ID observations. Unresolved\nor mismatched IDs reject the batch. The checks do not prove topology membership\nor completed destruction: older tmux may retain an unlinked pane through\nqueued references. The sequence provides interval observations and the same\nserver-incarnation guarantee as `get/3`. Ambient command configuration applies\nto both paths.\n\nStdout is bounded to 1 MiB and stderr to 64 KiB for the whole sequence, with\nthe endpoint's 2500 ms command deadline. Seven 32 KiB values fit even under\nthe qualified worst-case native quoting expansion. Larger external values\nmay exceed that aggregate output bound. Any command, framing or decoding\nfailure rejects the entire result, retaining native outcome and cleanup\nevidence. There is no partial-success result, hidden refresh or value cache."},"source":{"line":145,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-get_many-3"},{"id":"tmux_option:set/3","publicId":"tmux_option:set/3","qualifiedName":"tmux_option:set/3","name":"set/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Value)\n-spec set(scope(), key(), binary()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":33,"end":38,"target":"t:tmux_option:scope/0"},{"start":42,"end":45,"target":"t:tmux_option:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":49,"end":55,"target":"t:erlang:binary/0"},{"start":80,"end":104,"target":"t:tmux_operation:completed/0"},{"start":131,"end":153,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set one scalar or indexed array entry with default write options. Performs I/O; see `set/4` for append, only-if-unset, parsing and unknown-outcome semantics."},"source":{"line":164,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-set-3"},{"id":"tmux_option:set/4","publicId":"tmux_option:set/4","qualifiedName":"tmux_option:set/4","name":"set/4","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Value, Options)\n-spec set(scope(), key(), binary(), write_options()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":42,"end":47,"target":"t:tmux_option:scope/0"},{"start":51,"end":54,"target":"t:tmux_option:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":58,"end":64,"target":"t:erlang:binary/0"},{"start":68,"end":81,"target":"t:tmux_option:write_options/0"},{"start":106,"end":130,"target":"t:tmux_operation:completed/0"},{"start":157,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"write_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_option:write_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set a literal binary value, after scope/version/owner validation. Array writes require {Name, Index}; this avoids tmux's whole-array separator grammar. append uses tmux's type-specific -a semantics. only_if_unset checks the local table; already-set is a backend error, with no suppressed errors or compare-and-swap guarantee. Values must be supplied explicitly; an empty flag value retains tmux's native toggle behavior. A successful result proves command completion, not later effects of a stored command or format. Performs I/O; never retries."},"source":{"line":178,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-set-4"},{"id":"tmux_option:unset/2","publicId":"tmux_option:unset/2","qualifiedName":"tmux_option:unset/2","name":"unset/2","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"unset(Scope, Key)\n-spec unset(scope(), key()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":30,"end":35,"target":"t:tmux_option:scope/0"},{"start":39,"end":42,"target":"t:tmux_option:key/0"},{"start":69,"end":93,"target":"t:tmux_operation:completed/0"},{"start":122,"end":144,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove a local option or one indexed entry. Removing a local option restores inheritance; removing an entry leaves a local array, possibly empty. Unsetting a global built-in resets tmux's default; user options are removed. Missing local values are a successful tmux no-op. No pane-wide -U action is implied. Performs I/O and returns the command result without refreshing captured rows."},"source":{"line":198,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_option-unset-2"},{"id":"t:tmux_option:key/0","publicId":"t:tmux_option:key/0","qualifiedName":"tmux_option:key/0","name":"key/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() :: binary() | {binary(), non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":15,"end":21,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":37,"end":52,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical binary name; arrays use a structured non-negative index, never bracket syntax."},"source":{"line":44,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-key-0"},{"id":"t:tmux_option:metadata/0","publicId":"t:tmux_option:metadata/0","qualifiedName":"tmux_option:metadata/0","name":"metadata/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type metadata() ::\n          #{scopes := [server | session | window | pane],\n            type :=\n                choice | colour | command | flag | key |\n                number | string,\n            array := boolean(),\n            hook := boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":209,"end":216,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":240,"end":247,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-derived scope, parser type, array and executable-hook metadata."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-metadata-0"},{"id":"t:tmux_option:read_options/0","publicId":"t:tmux_option:read_options/0","qualifiedName":"tmux_option:read_options/0","name":"read_options/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type read_options() :: #{inherit => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":37,"end":44,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Local-only unless inherit is true. Unknown options and non-Booleans are errors."},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-read_options-0"},{"id":"t:tmux_option:scope/0","publicId":"t:tmux_option:scope/0","qualifiedName":"tmux_option:scope/0","name":"scope/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope() ::\n          tmux_model:session() |\n          tmux_model:window() |\n          tmux_model:pane() |\n          {server | session_defaults | window_defaults,\n           tmux_server:t()}.","params":[],"references":[{"start":27,"end":45,"target":"t:tmux_model:session/0"},{"start":60,"end":77,"target":"t:tmux_model:window/0"},{"start":92,"end":107,"target":"t:tmux_model:pane/0"},{"start":179,"end":192,"target":"t:tmux_server:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A registered local entity or an explicitly selected global option table."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-scope-0"},{"id":"t:tmux_option:value/0","publicId":"t:tmux_option:value/0","qualifiedName":"tmux_option:value/0","name":"value/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value() ::\n          binary() | #{non_neg_integer() => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":61,"end":67,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical tmux text bytes for a scalar/entry, or a sparse map for a whole array."},"source":{"line":54,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-value-0"},{"id":"t:tmux_option:write_options/0","publicId":"t:tmux_option:write_options/0","qualifiedName":"tmux_option:write_options/0","name":"write_options/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type write_options() ::\n          #{append => boolean(),\n            only_if_unset => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":47,"end":54,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":87,"end":94,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"append maps to -a; only_if_unset maps to -o and reports already-set errors. Both default false."},"source":{"line":52,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_option-write_options-0"},{"id":"tmux_pane","publicId":"tmux_pane","qualifiedName":"tmux_pane","name":"tmux_pane","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create, observe and rearrange panes using registered physical IDs.","body":"`split/2` accepts a pane or a window; a window means its active pane\nat execution. Options (`t:split_options/0`) are direction\n(horizontal or vertical), size ({cells, N} or {percent, N}), before,\nfull_size, zoom, cwd, env, launch and detach. It defaults to a detached\nvertical split. `get/2` returns newly observed fields; existing rows\nremain unchanged. Reads span several commands and do not claim atomicity.\nLaunch and environment options follow `tmux_session:create/2`. An absent or\nzero tmux pane_pid is represented as none. A captured positive PID is an\nobservation, not a guarantee that the process remains alive.\n\nA successful split followed by a failed observation retains the completed\nmutation and command result in its error. `kill/1` returns the\ncommand result. Detached or stale references cannot act. `resize_command/2`\nbuilds a reusable value without tmux I/O; the other calls perform I/O after\nvalidation.\n\n`send_text/2` sends up to 2,000 literal bytes, including NUL, in one\ncommand using tmux's hexadecimal key form. It adds no Enter key and never\nsplits a large input into partially applied commands. `send_keys/2`\naccepts up to 256 named keys, single UTF-8 characters, {function, 1..12} and\n{control, <<Letter>>}. Named keys are enter, tab, escape, backspace, space,\nup, down, left, right, home, 'end', insert, delete, page_up, page_down and\nback_tab. Terminal modes still govern how input is consumed; command\ncompletion does not mean a program processed it.\n\n`capture/2` returns stdout bytes unchanged, including final\nnewlines. Options (`t:capture_options/0`) are start and 'end' (line\nintegers or all), join_lines, escape_sequences, escape_control,\nretain_trailing_spaces, alternate, pending and quiet. Defaults are tmux's\ncurrent-screen capture without escapes, joined wraps or padding. The\nendpoint's output limit applies; an oversized capture returns an error.\n\nUse `join/3`, `move/3` and `swap/3` to rearrange existing panes without\nrespawning their processes. `break/4` takes an explicit source window link:\nbreaking a window's only pane moves that membership, while breaking one of\nseveral panes creates a new physical window. The [topology guide](panes.md)\nshows the distinction. Use `get/2` or a new snapshot for updated parents and\nindexes; actions leave captured values unchanged.\n\n`pipe/3` connects a tmux-owned shell process to pane output, input or both.\nIt protects the shell text from tmux hash/strftime expansion; shell quoting\nremains the caller's responsibility. `stop_pipe/1` closes that native pipe.\nThese actions do not create an Erlang output subscription or transfer process\nownership to the endpoint. Use an application acknowledgement for consumer\nreadiness, delivered bytes and job completion."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane"},{"id":"tmux_pane:break/4","publicId":"tmux_pane:break/4","qualifiedName":"tmux_pane:break/4","name":"break/4","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"break(Pane, SourceLink, Session, Options)\n-spec break(tmux_model:pane(),\n            tmux_model:window_link(),\n            tmux_model:session(),\n            break_options()) ->\n               {ok, tmux_operation:completed()} |\n               {error, map()}.","references":[{"start":54,"end":69,"target":"t:tmux_model:pane/0"},{"start":85,"end":107,"target":"t:tmux_model:window_link/0"},{"start":123,"end":141,"target":"t:tmux_model:session/0"},{"start":157,"end":170,"target":"t:tmux_pane:break_options/0"},{"start":197,"end":221,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":250,"end":253,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"SourceLink","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"break_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_pane:break_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Break a physical pane through its explicit source membership into a destination session/index. Source, link and session must have the same registered owner. The source link's expected window and the pane's observed parent are checked before dispatch. The source selector also includes the stable pane ID, never its positional index. Preflight and action are not atomic.","body":"With multiple panes, tmux creates a new physical window. With only one pane,\nit moves the selected source membership, preserving the existing window and\nits other links. Moving the final membership out can remove the source session.\nPane IDs and processes remain; indexes and option inheritance can change.\nname is a literal UTF-8 argument, subject to native name cleaning.\nAn occupied destination index is refused. detach defaults true; false selects\nthe destination membership. Session groups retain native synchronization.\n\nReturns the command result consistently for both cases. Use `get/2` or\n`tmux_window_link:get/3` for fresh observations. Even an eventual native error\ncan unzoom a window; this is not a transaction and is never retried."},"source":{"line":211,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-break-4"},{"id":"tmux_pane:capture/2","publicId":"tmux_pane:capture/2","qualifiedName":"tmux_pane:capture/2","name":"capture/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"capture(Pane, Options)\n-spec capture(tmux_model:pane(), capture_options()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":37,"end":52,"target":"t:tmux_model:pane/0"},{"start":56,"end":71,"target":"t:tmux_pane:capture_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":100,"end":106,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":120,"end":123,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"capture_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_pane:capture_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture terminal bytes, preserving final newlines. Options select line range, joined wraps, escapes, alternate screen and padding; defaults follow tmux current-screen capture. Performs I/O and returns an explicit output-limit error instead of silently truncating."},"source":{"line":414,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-capture-2"},{"id":"tmux_pane:get/2","publicId":"tmux_pane:get/2","qualifiedName":"tmux_pane:get/2","name":"get/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:pane_id()) ->\n             {ok, tmux_model:pane()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":61,"target":"t:tmux_model:pane_id/0"},{"start":86,"end":101,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":115,"end":118,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:pane_id()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:pane_id/0"}]}],"returns":"{ok, tmux_model:pane()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read fresh fields for a physical pane ID. Performs I/O and returns target_gone for a vanished pane. A captured PID remains an observation, not a live-process guarantee."},"source":{"line":127,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-get-2"},{"id":"tmux_pane:join/3","publicId":"tmux_pane:join/3","qualifiedName":"tmux_pane:join/3","name":"join/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"join(Source, Destination, Options)\n-spec join(tmux_model:pane(),\n           tmux_model:pane(),\n           join_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:join_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"join_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:join_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Move a source pane into a split beside the destination pane. Both physical IDs must belong to the same registered owner and must differ. Geometry follows `t:join_options/0`. Existing processes and pane IDs survive; dimensions, indexes and inherited window options can change. Removing a window's last pane destroys that physical window and its links, and can remove sessions.","body":"Default detach true avoids selecting the resolved destination session; false\nuses tmux's resolved session context for the destination pane. Shared physical\nwindows affect all their memberships. Returns the command result without\nrefreshing either row. Use `get/2` for current fields. No retry is performed."},"source":{"line":236,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-join-3"},{"id":"tmux_pane:kill/1","publicId":"tmux_pane:kill/1","qualifiedName":"tmux_pane:kill/1","name":"kill/1","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Pane)\n-spec kill(tmux_model:pane()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":22,"end":37,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":63,"end":66,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":80,"end":83,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy this registered pane. Performs I/O after validating its origin and stable ID; it never falls back to a positional target."},"source":{"line":134,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-kill-1"},{"id":"tmux_pane:move/3","publicId":"tmux_pane:move/3","qualifiedName":"tmux_pane:move/3","name":"move/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"move(Source, Destination, Options)\n-spec move(tmux_model:pane(),\n           tmux_model:pane(),\n           join_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:join_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"join_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:join_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rearrange a source pane beside the destination, including within one window. Uses native move-pane, whose placement and lifetime behavior follow `join/3`. Both calls use explicit physical IDs and leave captured rows unchanged."},"source":{"line":245,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-move-3"},{"id":"tmux_pane:pipe/3","publicId":"tmux_pane:pipe/3","qualifiedName":"tmux_pane:pipe/3","name":"pipe/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"pipe/3\n-spec pipe(tmux_model:pane(),\n           pipe_command(),\n           pipe_options()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":18,"end":33,"target":"t:tmux_model:pane/0"},{"start":48,"end":60,"target":"t:tmux_pane:pipe_command/0"},{"start":75,"end":87,"target":"t:tmux_pane:pipe_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":130,"end":133,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Command","type":"pipe_command()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:pipe_command/0"}]},{"name":"Options","type":"pipe_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:pipe_options/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Connect a shell process to this registered physical pane, performing I/O. An explicit nonempty `#{shell => Command}` is required (`t:pipe_command/0`). tmux hash formats and strftime directives are escaped so the shell receives the supplied text. This does not quote values interpolated into shell code; the caller owns that quoting. Executable argv is not accepted by this shell-only native command. Encoding follows `tmux_command:literal_format/2` in time mode. A percent-bearing command above its native 8191-byte intermediate limit returns `format_limit` before dispatch, preserving any existing pipe.","body":"`direction` (`t:pipe_options/0`) is `output` (default: pane output to child\nstdin), `input` (child stdout to pane input) or `both`. `toggle` defaults false,\nreplacing any existing pipe. True maps to native `-o`: close an existing pipe without\nstarting another, or open one when none exists. A stopped pipe and replacement\ncan discard pending output. Await consumer acknowledgements before closing\nif delivered bytes matter. This is a live PTY byte stream, not rendered\ncapture text or replay of terminal history; terminal modes affect its bytes.\n\nThe child is started by tmux through `/bin/sh -c`. Its stderr is discarded;\nunused directions are routed to the native null device. No pane cwd or\nenvironment copying is promised. A successful command result does not prove\nexec success, readiness, delivery or child exit. The process is tmux-owned;\n`tmux_server:close/1` preserves the borrowed pane and its pipe. This is not an\nErlang subscription with library flow control. Use `stop_pipe/1` to close the\npipe; stopping is not process cancellation or a wait for job completion."},"source":{"line":165,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-pipe-3"},{"id":"tmux_pane:resize/2","publicId":"tmux_pane:resize/2","qualifiedName":"tmux_pane:resize/2","name":"resize/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"resize(Pane, Options)\n-spec resize(tmux_model:pane(), resize_options()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":35,"end":50,"target":"t:tmux_model:pane/0"},{"start":54,"end":68,"target":"t:tmux_pane:resize_options/0"},{"start":96,"end":120,"target":"t:tmux_operation:completed/0"},{"start":150,"end":172,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"resize_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_pane:resize_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request an absolute width, height or both for this registered physical pane. Performs I/O after validating dimensions and origin. tmux can clamp the request to its layout constraints and can resize neighboring panes. Resizing a tiled pane unzooms its window. Use `get/2` for actual dimensions; the input row is unchanged. The accepted library range is not a promise that every server accepts every dimension: tmux versions can impose tighter limits and return a command error.","body":"An empty request is rejected before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_pane:resize(invalid_row, #{}).\n{error,#{code => empty_resize}}"}]},"source":{"line":317,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-resize-2"},{"id":"tmux_pane:resize_command/2","publicId":"tmux_pane:resize_command/2","qualifiedName":"tmux_pane:resize_command/2","name":"resize_command/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"resize_command(Pane, Options)\n-spec resize_command(tmux_model:pane(), resize_options()) ->\n                        {ok, tmux_command:t()} |\n                        {error, map()}.","references":[{"start":51,"end":66,"target":"t:tmux_model:pane/0"},{"start":70,"end":84,"target":"t:tmux_pane:resize_options/0"},{"start":120,"end":134,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":172,"end":175,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"resize_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_pane:resize_options/0"}]}],"returns":"{ok, tmux_command:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a resize command without tmux I/O. Uses the dimensions and validation rules of `resize/2`, preserving the row's captured origin and stable pane ID. Endpoint liveness and native layout constraints are checked during execution. Submit through `tmux_server:command/3` or `tmux_operation:start/3`.","examples":[{"lang":"erlang","code":"1> tmux_pane:resize_command(invalid_row, #{}).\n{error,#{code => empty_resize}}"}]},"source":{"line":335,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-resize_command-2"},{"id":"tmux_pane:respawn/2","publicId":"tmux_pane:respawn/2","qualifiedName":"tmux_pane:respawn/2","name":"respawn/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"respawn(Pane, Options)\n-spec respawn(tmux_model:pane(), respawn_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":37,"end":52,"target":"t:tmux_model:pane/0"},{"start":56,"end":71,"target":"t:tmux_pane:respawn_options/0"},{"start":100,"end":124,"target":"t:tmux_operation:completed/0"},{"start":155,"end":177,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"respawn_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_pane:respawn_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn this registered physical pane, keeping its pane ID. force defaults false and a running pane normally returns command_error. force = true lets tmux close its existing PTY before spawning again. This acknowledges the tmux command, not former-job termination or successful application initialization. The old PTY can already be closed if a later spawn step fails.","body":"launch defaults to previous, reusing tmux's saved argv or shell. An explicit\nargv or shell map replaces that command. default_shell is invalid here because\nabsent respawn arguments mean saved-command reuse. Omitted cwd retains the\nsaved launch directory, rather than the program's current directory. env\naugments the session environment tmux resolves for this physical pane; a\ncaptured membership does not pin that context. Prior per-spawn overrides are\nnot automatically reapplied. Other launch rules follow\n`tmux_session:create/2`.\n\nPerforms I/O after validation. Existing rows retain their observations; use\n`get/2` and an application readiness condition to inspect the new process. An\nuncertain result is not permission to replay this mutation automatically.\n\nUnsupported launch modes fail before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_pane:respawn(invalid_row, #{launch => default_shell}).\n{error,#{code => invalid_launch}}"}]},"source":{"line":373,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-respawn-2"},{"id":"tmux_pane:send_keys/2","publicId":"tmux_pane:send_keys/2","qualifiedName":"tmux_pane:send_keys/2","name":"send_keys/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"send_keys(Pane, Keys)\n-spec send_keys(tmux_model:pane(), [key()]) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":38,"end":53,"target":"t:tmux_model:pane/0"},{"start":58,"end":61,"target":"t:tmux_pane:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":110,"end":113,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Keys","type":"[key()]","typeReferences":[{"start":1,"end":4,"target":"t:tmux_pane:key/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send at most 256 validated key tokens. Named keys, single UTF-8 characters, function keys and control-letter tuples are supported. Performs I/O; terminal modes determine the resulting input bytes. Use `send_text/2` for arbitrary bytes."},"source":{"line":401,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-send_keys-2"},{"id":"tmux_pane:send_text/2","publicId":"tmux_pane:send_text/2","qualifiedName":"tmux_pane:send_text/2","name":"send_text/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"send_text/2\n-spec send_text(tmux_model:pane(), binary()) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":28,"end":43,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":47,"end":53,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":84,"end":87,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":101,"end":104,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Bytes","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send at most 2,000 literal bytes as hexadecimal tmux keys. Adds no Enter key and does not invoke a shell. Performs I/O in one command; oversized input is rejected before partial submission. Completion does not prove that a terminal program processed the input."},"source":{"line":388,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-send_text-2"},{"id":"tmux_pane:split/2","publicId":"tmux_pane:split/2","qualifiedName":"tmux_pane:split/2","name":"split/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"split(Row, Options)\n-spec split(tmux_model:pane() | tmux_model:window(),\n            split_options()) ->\n               {ok, tmux_model:pane()} | {error, map()}.","references":[{"start":32,"end":47,"target":"t:tmux_model:pane/0"},{"start":52,"end":69,"target":"t:tmux_model:window/0"},{"start":85,"end":98,"target":"t:tmux_pane:split_options/0"},{"start":125,"end":140,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":154,"end":157,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"tmux_model:pane() | tmux_model:window()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"},{"start":20,"end":37,"target":"t:tmux_model:window/0"}]},{"name":"Options","type":"split_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_pane:split_options/0"}]}],"returns":"{ok, tmux_model:pane()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Split a pane, or the supplied window's active pane, and observe the new pane. Defaults to a detached vertical split. Options and launch semantics are described in the module docs. Performs I/O; a post-creation read error retains the completed mutation rather than pretending that no pane was created."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-split-2"},{"id":"tmux_pane:stop_pipe/1","publicId":"tmux_pane:stop_pipe/1","qualifiedName":"tmux_pane:stop_pipe/1","name":"stop_pipe/1","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"stop_pipe(Pane)\n-spec stop_pipe(tmux_model:pane()) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":32,"end":47,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":78,"end":81,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":95,"end":98,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Close this registered pane's native pipe, performing I/O. On a live pane, closing an already closed pipe succeeds. An exited pane can produce a native command error; a vanished ID returns `target_gone`.","body":"Closing can discard pending bytes. It neither kills nor waits for an arbitrary\nshell job started by `pipe/3`; applications must verify consumption and\nprocess completion themselves. The endpoint does not own that shell process."},"source":{"line":188,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-stop_pipe-1"},{"id":"tmux_pane:swap/3","publicId":"tmux_pane:swap/3","qualifiedName":"tmux_pane:swap/3","name":"swap/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"swap(Source, Destination, Options)\n-spec swap(tmux_model:pane(),\n           tmux_model:pane(),\n           swap_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:swap_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"swap_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:swap_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Exchange two panes' layout positions within or across physical windows. Preserves their IDs and processes; parent windows, dimensions, indexes and inherited options can change. Both rows require the same registered owner. detach defaults true; active positions can still receive different panes. zoom maps to native -Z. Identical IDs do not exchange panes, but native zoom handling still runs; the default can unzoom even a same-pane swap. Returns the command result; `get/2` observes the resulting values explicitly."},"source":{"line":258,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_pane-swap-3"},{"id":"t:tmux_pane:break_options/0","publicId":"t:tmux_pane:break_options/0","qualifiedName":"tmux_pane:break_options/0","name":"break_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type break_options() ::\n          #{index := tmux_window_link:index(),\n            name => binary(),\n            detach => boolean()}.","params":[],"references":[{"start":46,"end":68,"target":"t:tmux_window_link:index/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":92,"end":98,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":124,"end":131,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Break placement: explicit destination index, optional literal window name. detach defaults true."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-break_options-0"},{"id":"t:tmux_pane:capture_options/0","publicId":"t:tmux_pane:capture_options/0","qualifiedName":"tmux_pane:capture_options/0","name":"capture_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capture_options() ::\n          #{start => coordinate(),\n            'end' => coordinate(),\n            join_lines => boolean(),\n            escape_sequences => boolean(),\n            escape_control => boolean(),\n            retain_trailing_spaces => boolean(),\n            alternate => boolean(),\n            pending => boolean(),\n            quiet => boolean()}.","params":[],"references":[{"start":48,"end":58,"target":"t:tmux_pane:coordinate/0"},{"start":83,"end":93,"target":"t:tmux_pane:coordinate/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":123,"end":130,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":166,"end":173,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":207,"end":214,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":256,"end":263,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":292,"end":299,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":326,"end":333,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":358,"end":365,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture range and rendering flags. Byte output and its final newline are preserved."},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-capture_options-0"},{"id":"t:tmux_pane:coordinate/0","publicId":"t:tmux_pane:coordinate/0","qualifiedName":"tmux_pane:coordinate/0","name":"coordinate/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type coordinate() :: -2147483648..32767 | all.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A capture line coordinate, or all for tmux's full available range."},"source":{"line":91,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-coordinate-0"},{"id":"t:tmux_pane:join_options/0","publicId":"t:tmux_pane:join_options/0","qualifiedName":"tmux_pane:join_options/0","name":"join_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type join_options() ::\n          #{direction => horizontal | vertical,\n            size =>\n                {cells, 1..2147483647} | {percent, 1..100},\n            detach => boolean(),\n            before => boolean(),\n            full_size => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":174,"end":181,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":207,"end":214,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":243,"end":250,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Join/move geometry: detach true, vertical split by default. before and full_size follow tmux layout rules."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-join_options-0"},{"id":"t:tmux_pane:key/0","publicId":"t:tmux_pane:key/0","qualifiedName":"tmux_pane:key/0","name":"key/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() ::\n          binary() |\n          enter | tab | escape | backspace | space | up |\n          down | left | right | home | 'end' | insert |\n          delete | page_up | page_down | back_tab |\n          {function, 1..12} |\n          {control, binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":25,"end":31,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":252,"end":258,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated named key, single UTF-8 character, function key or control-letter key."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-key-0"},{"id":"t:tmux_pane:pipe_command/0","publicId":"t:tmux_pane:pipe_command/0","qualifiedName":"tmux_pane:pipe_command/0","name":"pipe_command/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pipe_command() :: #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":35,"end":41,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicit shell code: a nonempty NUL-free binary, with no tmux format or strftime expansion."},"source":{"line":59,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-pipe_command-0"},{"id":"t:tmux_pane:pipe_options/0","publicId":"t:tmux_pane:pipe_options/0","qualifiedName":"tmux_pane:pipe_options/0","name":"pipe_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pipe_options() ::\n          #{direction => output | input | both,\n            toggle => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":94,"end":101,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Pipe direction defaults to output. toggle defaults false; true closes an existing pipe instead of replacing it."},"source":{"line":61,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-pipe_options-0"},{"id":"t:tmux_pane:resize_options/0","publicId":"t:tmux_pane:resize_options/0","qualifiedName":"tmux_pane:resize_options/0","name":"resize_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type resize_options() ::\n          #{width := 1..65535, height => 1..65535} |\n          #{width => 1..65535, height := 1..65535}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Requested absolute pane dimensions in cells. Supply at least one dimension; tmux can clamp it to fit the layout."},"source":{"line":85,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-resize_options-0"},{"id":"t:tmux_pane:respawn_options/0","publicId":"t:tmux_pane:respawn_options/0","qualifiedName":"tmux_pane:respawn_options/0","name":"respawn_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_options() ::\n          #{force => boolean(),\n            launch => tmux_command:respawn_spec(),\n            cwd => binary(),\n            env => #{binary() => binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"start":81,"end":106,"target":"t:tmux_command:respawn_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":129,"end":135,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":172,"end":178,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn options. Defaults: force false, launch previous, saved cwd. Environment augments tmux's resolved session environment for this spawn."},"source":{"line":88,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-respawn_options-0"},{"id":"t:tmux_pane:split_options/0","publicId":"t:tmux_pane:split_options/0","qualifiedName":"tmux_pane:split_options/0","name":"split_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type split_options() ::\n          #{direction => horizontal | vertical,\n            size =>\n                {cells, 1..2147483647} | {percent, 1..100},\n            before => boolean(),\n            full_size => boolean(),\n            zoom => boolean(),\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":175,"end":182,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":211,"end":218,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":242,"end":249,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":272,"end":278,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":303,"end":309,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":315,"end":321,"target":"t:erlang:binary/0"},{"start":348,"end":372,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":398,"end":405,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Split geometry, placement and explicit launch options. Defaults to a detached vertical split."},"source":{"line":80,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-split_options-0"},{"id":"t:tmux_pane:swap_options/0","publicId":"t:tmux_pane:swap_options/0","qualifiedName":"tmux_pane:swap_options/0","name":"swap_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type swap_options() ::\n          #{detach => boolean(), zoom => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":46,"end":53,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":65,"end":72,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Swap controls: detach defaults true; zoom maps to tmux -Z to retain zoom."},"source":{"line":78,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_pane-swap_options-0"},{"id":"tmux_query","publicId":"tmux_query","qualifiedName":"tmux_query","name":"tmux_query","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Build and execute explicit queries over the tmux graph.","body":"Use `fetch/1` to execute a query. Constructors,\n`where/2`, `limit/2`, `pushdown/2` and\n`explain/1` perform no tmux I/O. Criteria are validated when added,\nand repeated conditions conjoin. Fetching returns an ordered `m:tmux_select`\nselection backed by a complete `m:tmux_snapshot` graph. By default the full\ncaptured view is filtered locally. Enable native candidate exclusion with\n`pushdown/2`: it can add a scan without reducing complete-graph hydration. The\ncandidate is a necessary condition; the full filter still runs before the limit.\n\nCaptures span commands and are not atomic. Candidate IDs excluded at one\nobservation cannot be recovered by later local filtering. Disabling\n`pushdown/2` evaluates the complete captured view without an\nearlier candidate exclusion. Numeric candidate fields come from the restricted\nscalar codec and must agree with the capture's scalar observations. Text and\nrelationships remain local.\n\nCaptures emit bounded OTP Logger reports with their snapshot ID and endpoint\ngeneration. See [runtime diagnostics](diagnostics.md) for observation cost,\nrejection reports and configuration.","examples":[{"lang":"erlang","code":"1> Q0 = tmux_query:panes(unopened), ok.\nok\n2> Q = tmux_query:where(#{width => #{gte => 120}}, Q0), ok.\nok\n3> maps:get(format, maps:get(candidate, tmux_query:explain(Q))).\n<<\"1\">>\n4> Pushed = tmux_query:pushdown(true, Q), ok.\nok\n5> maps:get(format, maps:get(candidate, tmux_query:explain(Pushed))).\n<<\"#{e|>=|:#{pane_width},120}\">>"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query"},{"id":"tmux_query:explain/1","publicId":"tmux_query:explain/1","qualifiedName":"tmux_query:explain/1","name":"explain/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"explain/1\n-spec explain(t()) -> plan().","references":[{"start":24,"end":25,"target":"t:tmux_query:t/0"},{"start":32,"end":36,"target":"t:tmux_query:plan/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"plan()","returnsReferences":[{"start":0,"end":4,"target":"t:tmux_query:plan/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Inspect command templates, necessary candidate conditions, full residual, hydration, required fields, ordering and temporal assumptions. Performs no I/O and does not contact the endpoint to claim dynamic capabilities."},"source":{"line":191,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-explain-1"},{"id":"tmux_query:fetch/1","publicId":"tmux_query:fetch/1","qualifiedName":"tmux_query:fetch/1","name":"fetch/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"fetch(Query)\n-spec fetch(t()) -> {ok, tmux_select:t()} | {error, map()}.","references":[{"start":25,"end":26,"target":"t:tmux_query:t/0"},{"start":38,"end":51,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":65,"end":68,"target":"t:erlang:map/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"{ok, tmux_select:t()} | {error, map()}","returnsReferences":[{"start":5,"end":18,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute with default capture bounds and no retry. Returns an ordered selection whose complete graph remains locally readable. See `fetch/2` for resource limits, requested retries and operational errors."},"source":{"line":215,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-fetch-1"},{"id":"tmux_query:fetch/2","publicId":"tmux_query:fetch/2","qualifiedName":"tmux_query:fetch/2","name":"fetch/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"fetch/2\n-spec fetch(t(), fetch_options()) ->\n               {ok, tmux_select:t()} | {error, map()}.","references":[{"start":20,"end":21,"target":"t:tmux_query:t/0"},{"start":25,"end":38,"target":"t:tmux_query:fetch_options/0"},{"start":65,"end":78,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]},{"name":"Options","type":"fetch_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_query:fetch_options/0"}]}],"returns":"{ok, tmux_select:t()} | {error, map()}","returnsReferences":[{"start":5,"end":18,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute the planned observation, full local predicate and final limit.","body":"Capture options are those of `tmux_server:snapshot/2`. retry is 0 (default) or\n1 and retries only inconsistent_capture, within the original capture deadline.\nThe retry is a new read-only capture. No mutations are retried. Invalid\ncapture requests return tagged errors, including unsupported consistency.","examples":[{"lang":"erlang","code":"1> tmux_query:fetch(tmux_query:panes(unopened), #{retry => 2}).\n{error,#{code => invalid_query_options}}"}]},"source":{"line":231,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-fetch-2"},{"id":"tmux_query:limit/2","publicId":"tmux_query:limit/2","qualifiedName":"tmux_query:limit/2","name":"limit/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"limit/2\n-spec limit(0..65536, t()) -> t().","references":[{"start":30,"end":31,"target":"t:tmux_query:t/0"},{"start":38,"end":39,"target":"t:tmux_query:t/0"}],"params":[{"name":"Count","type":"0..65536","typeReferences":[]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set a final result limit from 0 through 65536, applied after residual filtering and identity handling. It is not a candidate-fetch limit. Performs no I/O; invalid counts raise bad_query_limit."},"source":{"line":172,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-limit-2"},{"id":"tmux_query:panes/1","publicId":"tmux_query:panes/1","qualifiedName":"tmux_query:panes/1","name":"panes/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Server)\n-spec panes(tmux_server:t()) -> t().","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":46,"end":47,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future server-wide physical pane query. Performs no I/O; `fetch/1` is the execution boundary."},"source":{"line":128,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-panes-1"},{"id":"tmux_query:pushdown/2","publicId":"tmux_query:pushdown/2","qualifiedName":"tmux_query:pushdown/2","name":"pushdown/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"pushdown(Enabled, Query)\n-spec pushdown(boolean(), t()) -> t().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":40,"end":47,"target":"t:erlang:boolean/0"},{"start":51,"end":52,"target":"t:tmux_query:t/0"},{"start":59,"end":60,"target":"t:tmux_query:t/0"}],"params":[{"name":"Enabled","type":"boolean()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Enable or disable native candidate exclusion, returning a new query. The default is disabled: evaluate the complete captured view locally. Enabling it can add a candidate scan without reducing hydration; neither mode promises an atomic graph. Performs no I/O."},"source":{"line":183,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-pushdown-2"},{"id":"tmux_query:sessions/1","publicId":"tmux_query:sessions/1","qualifiedName":"tmux_query:sessions/1","name":"sessions/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Server)\n-spec sessions(tmux_server:t()) -> t().","references":[{"start":32,"end":45,"target":"t:tmux_server:t/0"},{"start":52,"end":53,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future server-wide session query without executing tmux."},"source":{"line":144,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-sessions-1"},{"id":"tmux_query:where/2","publicId":"tmux_query:where/2","qualifiedName":"tmux_query:where/2","name":"where/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"where/2\n-spec where(map() | tmux_filter:t(), t()) -> t().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"start":28,"end":41,"target":"t:tmux_filter:t/0"},{"start":45,"end":46,"target":"t:tmux_query:t/0"},{"start":53,"end":54,"target":"t:tmux_query:t/0"}],"params":[{"name":"Criteria","type":"map() | tmux_filter:t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":21,"target":"t:tmux_filter:t/0"}]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate trusted criteria for this entity and conjoin them with prior conditions. Successive calls share the same normalized resource limits as one flat conjunction. Each relationship quantifier retains its own scope. Returns a new immutable query; malformed criteria raise bad_filter. Performs no I/O."},"source":{"line":153,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-where-2"},{"id":"tmux_query:window_links/1","publicId":"tmux_query:window_links/1","qualifiedName":"tmux_query:window_links/1","name":"window_links/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Server)\n-spec window_links(tmux_server:t()) -> t().","references":[{"start":40,"end":53,"target":"t:tmux_server:t/0"},{"start":60,"end":61,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future query over session-relative window memberships. Repeated physical windows retain distinct membership identity. Performs no I/O."},"source":{"line":139,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-window_links-1"},{"id":"tmux_query:windows/1","publicId":"tmux_query:windows/1","qualifiedName":"tmux_query:windows/1","name":"windows/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Server)\n-spec windows(tmux_server:t()) -> t().","references":[{"start":30,"end":43,"target":"t:tmux_server:t/0"},{"start":50,"end":51,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future query over unique physical windows. Performs no I/O."},"source":{"line":133,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_query-windows-1"},{"id":"t:tmux_query:candidate/0","publicId":"t:tmux_query:candidate/0","qualifiedName":"tmux_query:candidate/0","name":"candidate/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type candidate() ::\n          #{format := binary(),\n            exact := boolean(),\n            local_only := [local_reason()],\n            numeric_range => {0, 9007199254740991}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":74,"end":81,"target":"t:erlang:boolean/0"},{"start":112,"end":124,"target":"t:tmux_query:local_reason/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native necessary condition. format is a rendered tmux expression; exact means the translation covers the whole predicate for one observed state. A true fallback can admit every row. numeric_range describes qualified integer conversion, and is omitted for disabled/oversized fallback plans."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-candidate-0"},{"id":"t:tmux_query:command_plan/0","publicId":"t:tmux_query:command_plan/0","qualifiedName":"tmux_query:command_plan/0","name":"command_plan/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_plan() ::\n          #{initial_spine := [source_command()],\n            candidate := [source_command()],\n            hydration := [source_command()],\n            isolated_hydration := [source_command()],\n            final_spine := [source_command()],\n            empty_server := skip_window_and_pane_scans}.","params":[],"references":[{"start":54,"end":68,"target":"t:tmux_query:source_command/0"},{"start":99,"end":113,"target":"t:tmux_query:source_command/0"},{"start":144,"end":158,"target":"t:tmux_query:source_command/0"},{"start":198,"end":212,"target":"t:tmux_query:source_command/0"},{"start":245,"end":259,"target":"t:tmux_query:source_command/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture phases: initial identity/scalar scans, optional candidate scans, complete text/byte hydration and final identity/scalar scans. hydration gives the default batched templates; isolated_hydration describes the explicit isolated option and unqualified-field fallback. An empty server skips window/pane scans. Execution still validates capture bounds and can fail."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-command_plan-0"},{"id":"t:tmux_query:fetch_options/0","publicId":"t:tmux_query:fetch_options/0","qualifiedName":"tmux_query:fetch_options/0","name":"fetch_options/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type fetch_options() ::\n          #{deadline_ms => 1..600000,\n            max_rows => 1..65536,\n            max_bytes => 1..67108864,\n            hydration => tmux_server:hydration(),\n            consistency => observed | atomic,\n            retry => 0 | 1}.","params":[],"references":[{"start":160,"end":181,"target":"t:tmux_server:hydration/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture bounds plus an explicitly requested single inconsistent-capture retry; default retry is zero."},"source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-fetch_options-0"},{"id":"t:tmux_query:local_reason/0","publicId":"t:tmux_query:local_reason/0","qualifiedName":"tmux_query:local_reason/0","name":"local_reason/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type local_reason() ::\n          #{reason :=\n                disabled | format_limit | inexact_negation |\n                unqualified_scalar_codec |\n                complete_relationship_required,\n            field => binary(),\n            relation => binary(),\n            operator => tmux_schema:operator()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":219,"end":225,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":253,"end":259,"target":"t:erlang:binary/0"},{"start":287,"end":307,"target":"t:tmux_schema:operator/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Why part of a predicate stays local. field and relation contain stable schema IDs, not Erlang names or tmux formats. An unsupported leaf may broaden the native condition; it never removes the full local predicate."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-local_reason-0"},{"id":"t:tmux_query:plan/0","publicId":"t:tmux_query:plan/0","qualifiedName":"tmux_query:plan/0","name":"plan/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type plan() ::\n          #{entity := tmux_schema:entity(),\n            pushdown := boolean(),\n            candidate := candidate(),\n            residual := tmux_filter:wire_document(),\n            required := [tmux_snapshot:requirement()],\n            limit := infinity | 0..65536,\n            commands := command_plan(),\n            hydration := complete_graph,\n            ordering := session_index_window | numeric_id,\n            deduplication := membership | physical_id,\n            capabilities :=\n                #{minimum_tmux := binary(),\n                  transport := one_shot},\n            consistency := observed,\n            atomic := false,\n            candidate_scalars :=\n                same_row_checked_against_spine,\n            text_and_relations := later_observations,\n            temporal_limit :=\n                excluded_rows_cannot_be_recovered}.","params":[],"references":[{"start":38,"end":56,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":84,"end":91,"target":"t:erlang:boolean/0"},{"start":120,"end":129,"target":"t:tmux_query:candidate/0"},{"start":157,"end":182,"target":"t:tmux_filter:wire_document/0"},{"start":211,"end":236,"target":"t:tmux_snapshot:requirement/0"},{"start":307,"end":319,"target":"t:tmux_query:command_plan/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":540,"end":546,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Pure explanation of a query. pushdown reports whether candidate exclusion is enabled (disabled by default). residual is the full portable predicate, required lists coverage requirements, and limit applies after residual evaluation. ordering and deduplication name the identity policy, not arbitrary map order. capabilities describes the planner baseline without probing a live endpoint.","body":"Capture spans commands. Candidate scalar values are checked against the first\nscan; text and relationships are later observations. Excluded rows cannot be\nrecovered after state changes. Even an exact candidate is not an atomic query."},"source":{"line":107,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-plan-0"},{"id":"t:tmux_query:source_command/0","publicId":"t:tmux_query:source_command/0","qualifiedName":"tmux_query:source_command/0","name":"source_command/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_command() ::\n          #{entity := tmux_schema:entity(),\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := scalar_spine,\n            kind := tmux_schema:entity(),\n            args := [binary()],\n            filter => binary()} |\n          #{entity := tmux_schema:entity(),\n            fields := [atom()],\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := escaped_columns_v1,\n            args := [binary()]} |\n          #{entity := tmux_schema:entity(),\n            field := atom(),\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := id_prefixed_quoted_field,\n            target := observed_id}.","params":[],"references":[{"start":48,"end":66,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":93,"end":99,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":125,"end":131,"target":"t:erlang:binary/0"},{"start":225,"end":243,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":268,"end":274,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":301,"end":307,"target":"t:erlang:binary/0"},{"start":335,"end":353,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":380,"end":384,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":412,"end":418,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":444,"end":450,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":551,"end":557,"target":"t:erlang:binary/0"},{"start":586,"end":604,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":629,"end":633,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":660,"end":666,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":692,"end":698,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Diagnostic command template, not executable argv. Scan templates carry args; text/byte hydration escapes each field once before column framing. Unqualified schema fields use isolated target = observed_id templates, resolved only while capturing. codec states how returned data is framed, including the version-specific print layer. This value grants no atomicity or persistent-connection guarantee."},"source":{"line":75,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-source_command-0"},{"id":"t:tmux_query:t/0","publicId":"t:tmux_query:t/0","qualifiedName":"tmux_query:t/0","name":"t/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An immutable description of future tmux reads. Only fetch executes it."},"source":{"line":121,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_query-t-0"},{"id":"tmux_schema","publicId":"tmux_schema","qualifiedName":"tmux_schema","name":"tmux_schema","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Validate schema-defined observations and normalize scalar values.","body":"Field names come from the generated registry, never record reflection or\npayload-created atoms. Text is validated UTF-8; byte fields preserve arbitrary\nbinaries. Integer normalization uses the shared exact JSON integer range.\n`m:tmux_model` validates rows and `m:tmux_filter` validates criteria through\nthis schema. The [field reference](fields.md) lists fields and relationships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema"},{"id":"tmux_schema:field/2","publicId":"tmux_schema:field/2","qualifiedName":"tmux_schema:field/2","name":"field/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"field(Entity, Field)\n-spec field(entity(), atom()) ->\n               {ok, field_metadata()} |\n               {error, error_detail()}.","references":[{"start":33,"end":39,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":43,"end":47,"target":"t:erlang:atom/0"},{"start":74,"end":88,"target":"t:tmux_schema:field_metadata/0"},{"start":117,"end":129,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]},{"name":"Field","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]}],"returns":"{ok, field_metadata()} | {error, error_detail()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_schema:field_metadata/0"},{"start":33,"end":45,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up one permitted field by its Erlang atom name. Unknown names return a tagged error; this does not turn input strings into atoms."},"source":{"line":78,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-field-2"},{"id":"tmux_schema:fields/1","publicId":"tmux_schema:fields/1","qualifiedName":"tmux_schema:fields/1","name":"fields/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"fields(Entity)\n-spec fields(entity()) ->\n                {ok, #{atom() => field_metadata()}} |\n                {error, error_detail()}.","references":[{"start":28,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":64,"end":68,"target":"t:erlang:atom/0"},{"start":74,"end":88,"target":"t:tmux_schema:field_metadata/0"},{"start":119,"end":131,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]}],"returns":"{ok, #{atom() => field_metadata()}} |\n          {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":7,"end":11,"target":"t:erlang:atom/0"},{"start":17,"end":31,"target":"t:tmux_schema:field_metadata/0"},{"start":56,"end":68,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return generated field metadata for a known entity, or a tagged unknown_entity error. Field names, wire names and stable IDs are allowlisted; this is not reflection over arbitrary record fields."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-fields-1"},{"id":"tmux_schema:normalize/2","publicId":"tmux_schema:normalize/2","qualifiedName":"tmux_schema:normalize/2","name":"normalize/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"normalize/2\n-spec normalize(entity(), map()) ->\n                   {ok, map()} | {error, error_detail()}.","references":[{"start":28,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":72,"end":75,"target":"t:erlang:map/0"},{"start":89,"end":101,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]},{"name":"Input","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"returns":"{ok, map()} | {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"start":22,"end":34,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate a domain-field map and normalize its scalar observations, retaining not_loaded/unavailable distinctly and deriving schema-defined values. Performs no I/O; constructors and action boundaries still validate records."},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-normalize-2"},{"id":"tmux_schema:operators/1","publicId":"tmux_schema:operators/1","qualifiedName":"tmux_schema:operators/1","name":"operators/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"operators/1\n-spec operators(#{type := value_type(),\n                  nullable := boolean(),\n                  atom() => term()}) ->\n                   [operator()].","references":[{"start":38,"end":48,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":82,"end":89,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":121,"end":125,"target":"t:erlang:term/0"},{"start":153,"end":161,"target":"t:tmux_schema:operator/0"}],"params":[{"name":"Argument1","type":"#{type := value_type(),\n            nullable := boolean(),\n            atom() => term()}","typeReferences":[{"start":10,"end":20,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":71,"end":75,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":81,"end":85,"target":"t:erlang:term/0"}]}],"returns":"[operator()]","returnsReferences":[{"start":1,"end":9,"target":"t:tmux_schema:operator/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the permitted scalar operators for this field type and nullability. The generated field reference uses this same validator. Performs no I/O."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-operators-1"},{"id":"tmux_schema:relations/1","publicId":"tmux_schema:relations/1","qualifiedName":"tmux_schema:relations/1","name":"relations/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"relations(Entity)\n-spec relations(entity()) ->\n                   {ok, #{atom() => relation_metadata()}} |\n                   {error, error_detail()}.","references":[{"start":34,"end":40,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":73,"end":77,"target":"t:erlang:atom/0"},{"start":83,"end":100,"target":"t:tmux_schema:relation_metadata/0"},{"start":134,"end":146,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]}],"returns":"{ok, #{atom() => relation_metadata()}} |\n          {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":7,"end":11,"target":"t:erlang:atom/0"},{"start":17,"end":34,"target":"t:tmux_schema:relation_metadata/0"},{"start":59,"end":71,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return generated relationship metadata, including target entities and one/many cardinality. Performs no I/O."},"source":{"line":67,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-relations-1"},{"id":"tmux_schema:value/2","publicId":"tmux_schema:value/2","qualifiedName":"tmux_schema:value/2","name":"value/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"value/2\n-spec value(map(), term()) ->\n               {ok, term()} | {error, error_detail()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":27,"end":31,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":58,"end":62,"target":"t:erlang:term/0"},{"start":76,"end":88,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Argument1","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]},{"name":"Argument2","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, term()} | {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":5,"end":9,"target":"t:erlang:term/0"},{"start":23,"end":35,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate and normalize one value against generated field metadata. Integral JSON numbers obey the exact shared integer range and field bounds; text is validated UTF-8, while bytes remain arbitrary binaries. Performs no I/O."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_schema-value-2"},{"id":"t:tmux_schema:entity/0","publicId":"t:tmux_schema:entity/0","qualifiedName":"tmux_schema:entity/0","name":"entity/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type entity() :: session | window | window_link | pane.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"The built-in tmux graph entities; window_link represents a session membership."},"source":{"line":18,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-entity-0"},{"id":"t:tmux_schema:error_detail/0","publicId":"t:tmux_schema:error_detail/0","qualifiedName":"tmux_schema:error_detail/0","name":"error_detail/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type error_detail() ::\n          #{code := atom(),\n            path := [term()],\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":44,"end":48,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":73,"end":77,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":94,"end":98,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":104,"end":108,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Structured boundary validation errors with a code and input path."},"source":{"line":22,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-error_detail-0"},{"id":"t:tmux_schema:field_metadata/0","publicId":"t:tmux_schema:field_metadata/0","qualifiedName":"tmux_schema:field_metadata/0","name":"field_metadata/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type field_metadata() ::\n          #{type := value_type(),\n            wire := binary(),\n            stable := binary(),\n            required := boolean(),\n            nullable := boolean(),\n            format => binary(),\n            capture_codec => escaped_columns_v1,\n            minimum => integer()}.","params":[],"references":[{"start":46,"end":56,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":80,"end":86,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":112,"end":118,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":146,"end":153,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":181,"end":188,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":214,"end":220,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":296,"end":303,"target":"t:erlang:integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Generated field contract. stable is a versioned portable identity; wire is the JSON key. required controls construction and nullable permits known absence. format is present only for directly observed tmux fields; derived fields omit it. capture_codec identifies an admitted batched source encoding; its absence selects isolated reads for that entity. minimum tightens an integer field's lower bound. Field names themselves are the keys returned by `fields/1`, not this map's wire or stable values."},"source":{"line":35,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-field_metadata-0"},{"id":"t:tmux_schema:operator/0","publicId":"t:tmux_schema:operator/0","qualifiedName":"tmux_schema:operator/0","name":"operator/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type operator() ::\n          equals | 'not' | in | not_in | lt | lte | gt |\n          gte | contains | starts_with | ends_with | regex |\n          present.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validated scalar operators. The field's type and nullability restrict this set."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-operator-0"},{"id":"t:tmux_schema:relation_metadata/0","publicId":"t:tmux_schema:relation_metadata/0","qualifiedName":"tmux_schema:relation_metadata/0","name":"relation_metadata/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type relation_metadata() ::\n          #{kind := one | many,\n            target := entity(),\n            wire := binary(),\n            stable := binary()}.","params":[],"references":[{"start":83,"end":89,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":113,"end":119,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":145,"end":151,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Generated relationship contract: kind is one or many; target names the related entity. wire and stable have the same roles as in `t:field_metadata/0`. Completeness belongs to snapshot coverage, not this static schema."},"source":{"line":43,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-relation_metadata-0"},{"id":"t:tmux_schema:value_type/0","publicId":"t:tmux_schema:value_type/0","qualifiedName":"tmux_schema:value_type/0","name":"value_type/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value_type() ::\n          session_id | window_id | pane_id | boolean |\n          uint | integer | text | bytes.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Scalar categories used by normalization and operator validation; IDs remain binaries."},"source":{"line":24,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_schema-value_type-0"},{"id":"tmux_scope","publicId":"tmux_scope","qualifiedName":"tmux_scope","name":"tmux_scope","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Run synchronous work and cleanup while preserving both outcomes.","body":"Use `run/2` around a resource whose handle remains in the caller's scope.\nUse `run_or_error/2` for nested scopes or fail-fast programs that need the\ncallback's value directly and raise when cleanup fails.\n`tmux_server:with_server/2` and `tmux_server:with_owned/2` also acquire their\nresources and add recovery handles when cleanup fails. This module owns no\nprocess, timeout or retry policy; the supplied functions own those contracts."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_scope"},{"id":"tmux_scope:run/2","publicId":"tmux_scope:run/2","qualifiedName":"tmux_scope:run/2","name":"run/2","namespace":"tmux_scope","parent":"tmux_scope","kind":"function","modifiers":[],"signatures":[{"raw":"run(Function, Cleanup)\n-spec run(fun(() -> Value),\n          fun(() -> ok | {error, term()})) ->\n             {ok, Value} | {error, failure()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":84,"end":88,"target":"t:erlang:term/0"},{"start":132,"end":139,"target":"t:tmux_scope:failure/0"}],"params":[{"name":"Function","type":"fun(() -> Value)","typeReferences":[]},{"name":"Cleanup","type":"fun(() -> ok | {error, term()})","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"returns":"{ok, Value} | {error, failure()}","returnsReferences":[{"start":22,"end":29,"target":"t:tmux_scope:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Run a callback, then attempt cleanup once, synchronously in the calling process. This function performs only the I/O supplied by those functions. The callback has no library duration timer. Abrupt uncatchable caller death remains subject to each resource's existing ownership policy.","body":"Only ok proves cleanup success. Normalize resource-specific successful replies\ninside the cleanup function. With successful cleanup, return {ok, Value} or\nre-raise the original callback exception with its reason and stack. A callback\nreturning an error tuple is an ordinary value. Cleanup failure instead returns\n{error, Failure} with `t:failure/0`, preserving both outcomes. An unexpected\ncleanup return is recorded as invalid_cleanup_result.\n\nHandle an inner scope's error explicitly when nesting scopes. Otherwise it is\nan ordinary outer callback value. Keep resource handles for recovery; this\nfunction does not infer ownership or retry cleanup.","examples":[{"lang":"erlang","code":"1> tmux_scope:run(fun() -> done end, fun() -> ok end).\n{ok,done}\n2> tmux_scope:run(fun() -> done end, fun() -> {error, enoent} end).\n{error,#{code => scope_cleanup_failed,\n         primary => {ok,done},cleanup => {error,enoent}}}\n3> Work = fun() -> error(build_failed) end, ok.\nok\n4> {error, F} = tmux_scope:run(Work, fun() -> {error, busy} end), ok.\nok\n5> {exception, error, build_failed, [_ | _]} = maps:get(primary, F), ok.\nok\n6> maps:get(cleanup, F).\n{error,busy}"}]},"source":{"line":61,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_scope-run-2"},{"id":"tmux_scope:run_or_error/2","publicId":"tmux_scope:run_or_error/2","qualifiedName":"tmux_scope:run_or_error/2","name":"run_or_error/2","namespace":"tmux_scope","parent":"tmux_scope","kind":"function","modifiers":[],"signatures":[{"raw":"run_or_error(Function, Cleanup)\n-spec run_or_error(fun(() -> Value),\n                   fun(() -> ok | {error, term()})) ->\n                      Value.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:term/0"}],"params":[{"name":"Function","type":"fun(() -> Value)","typeReferences":[]},{"name":"Cleanup","type":"fun(() -> ok | {error, term()})","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"returns":"Value","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Run work and cleanup with `run/2`, returning the callback value directly. Raises {scope_cleanup_failed, Failure} if cleanup fails, retaining both outcomes in `t:failure/0`. With successful cleanup, callback exceptions retain their original reason and stack. Nested raising scopes propagate an inner failure through the outer scope while still attempting outer cleanup."},"source":{"line":84,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_scope-run_or_error-2"},{"id":"t:tmux_scope:exception/0","publicId":"t:tmux_scope:exception/0","qualifiedName":"tmux_scope:exception/0","name":"exception/0","namespace":"tmux_scope","parent":"tmux_scope","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type exception() ::\n          {exception,\n           error | exit | throw,\n           term(),\n           erlang:stacktrace()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":87,"end":91,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":106,"end":123,"target":"t:erlang:stacktrace/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"The original exception class, reason and stack, retained as evidence."},"source":{"line":16,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_scope-exception-0"},{"id":"t:tmux_scope:failure/0","publicId":"t:tmux_scope:failure/0","qualifiedName":"tmux_scope:failure/0","name":"failure/0","namespace":"tmux_scope","parent":"tmux_scope","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type failure() ::\n          #{code := scope_cleanup_failed,\n            primary := {ok, term()} | exception(),\n            cleanup := {error, term()} | exception(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":89,"end":93,"target":"t:erlang:term/0"},{"start":99,"end":108,"target":"t:tmux_scope:exception/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":143,"end":147,"target":"t:erlang:term/0"},{"start":153,"end":162,"target":"t:tmux_scope:exception/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":178,"end":182,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":188,"end":192,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Both outcomes when cleanup failed. primary contains the callback's ordinary return or exception; cleanup contains its separate error or exception. Resource-specific wrappers may add recovery handles to this map."},"source":{"line":22,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_scope-failure-0"},{"id":"tmux_select","publicId":"tmux_select","qualifiedName":"tmux_select","name":"tmux_select","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Filter ordered captured rows without tmux I/O.","body":"Use `panes/1`, `windows/1`,\n`window_links/1` or `sessions/1` with a\n`m:tmux_snapshot` to retain graph coverage. `from_list/2`\npreserves supplied order, duplicates and row origins; it establishes only\nfields present in every row and loads no relationships. Filtering and\n`take/2` retain the original coverage even if no rows remain.\n\n`where/2` accepts map criteria or a `t:tmux_filter:t/0` portable\nfilter. `filter/2` accepts a unary Boolean function, whose\nexceptions propagate. Cardinality criteria validate the whole expression and\nits coverage before stopping at sufficient evidence. Selections are opaque\nvalues; use `to_list/1` for functions in `m:lists`.\n\nA snapshot-backed selection retains the complete captured graph, including\nrows removed by filtering. After relationship evaluation, store the result of\n`to_list/1` and release other snapshot and selection references to allow that\ncontext to be collected. Row extraction preserves the supplied field binaries;\ncaller-created subbinaries can still retain their backing allocation."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select"},{"id":"tmux_select:count/1","publicId":"tmux_select:count/1","qualifiedName":"tmux_select:count/1","name":"count/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"count(Selection)\n-spec count(t()) -> non_neg_integer().","references":[{"start":29,"end":30,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":37,"end":52,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the current materialized row count without I/O."},"source":{"line":290,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-count-1"},{"id":"tmux_select:count/2","publicId":"tmux_select:count/2","qualifiedName":"tmux_select:count/2","name":"count/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"count/2\n-spec count(criteria(), t()) -> non_neg_integer().","references":[{"start":20,"end":28,"target":"t:tmux_select:criteria/0"},{"start":32,"end":33,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the exact local match count after full criteria and coverage validation. Performs no I/O."},"source":{"line":296,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-count-2"},{"id":"tmux_select:exists/1","publicId":"tmux_select:exists/1","qualifiedName":"tmux_select:exists/1","name":"exists/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"exists/1\n-spec exists(t()) -> boolean().","references":[{"start":22,"end":23,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":30,"end":37,"target":"t:erlang:boolean/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return whether this materialized selection is nonempty, without I/O."},"source":{"line":279,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-exists-1"},{"id":"tmux_select:exists/2","publicId":"tmux_select:exists/2","qualifiedName":"tmux_select:exists/2","name":"exists/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"exists(Criteria, Selection)\n-spec exists(criteria(), t()) -> boolean().","references":[{"start":41,"end":49,"target":"t:tmux_select:criteria/0"},{"start":53,"end":54,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":61,"end":68,"target":"t:erlang:boolean/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate all criteria/coverage first, then stop at the first local match. Performs no I/O; an empty selection does not bypass validation."},"source":{"line":285,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-exists-2"},{"id":"tmux_select:filter/2","publicId":"tmux_select:filter/2","qualifiedName":"tmux_select:filter/2","name":"filter/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"filter/2\n-spec filter(fun((Row) -> boolean()), t(Row)) -> t(Row)\n                when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":35,"end":42,"target":"t:erlang:boolean/0"},{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":58,"end":59,"target":"t:tmux_select:t/1"},{"start":93,"end":107,"target":"t:tmux_model:row/0"}],"params":[{"name":"Predicate","type":"fun((Row) -> boolean())","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":13,"end":20,"target":"t:erlang:boolean/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Apply an ordinary unary Boolean function locally, preserving row order and context. Non-Booleans and callback failures propagate; they are not false matches. This is executable application code, not portable filter data."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-filter-2"},{"id":"tmux_select:first/1","publicId":"tmux_select:first/1","qualifiedName":"tmux_select:first/1","name":"first/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"first/1\n-spec first(t(Row)) -> {ok, Row} | none\n               when Row :: tmux_model:row().","references":[{"start":20,"end":21,"target":"t:tmux_select:t/1"},{"start":75,"end":89,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | none","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the first current row or none. Additional matches are allowed. Performs no I/O."},"source":{"line":219,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-first-1"},{"id":"tmux_select:first/2","publicId":"tmux_select:first/2","qualifiedName":"tmux_select:first/2","name":"first/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"first(Criteria, Selection)\n-spec first(criteria(), t(Row)) -> {ok, Row} | none\n               when Row :: tmux_model:row().","references":[{"start":39,"end":47,"target":"t:tmux_select:criteria/0"},{"start":51,"end":52,"target":"t:tmux_select:t/1"},{"start":106,"end":120,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | none","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria and coverage, then stop at the first local match. Returns none when no row matches; performs no I/O."},"source":{"line":226,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-first-2"},{"id":"tmux_select:fold/3","publicId":"tmux_select:fold/3","qualifiedName":"tmux_select:fold/3","name":"fold/3","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"fold/3\n-spec fold(fun((Row, Acc) -> Acc), Acc, t(Row)) -> Acc\n              when Row :: tmux_model:row().","references":[{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":88,"end":102,"target":"t:tmux_model:row/0"}],"params":[{"name":"Function","type":"fun((Row, Acc) -> Acc)","typeReferences":[]},{"name":"Accumulator","type":"Acc","typeReferences":[]},{"name":"Argument3","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Acc","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Fold over current rows in order without I/O, using the function, accumulator, selection argument order. Arbitrary results are ordinary Erlang values."},"source":{"line":179,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-fold-3"},{"id":"tmux_select:from_list/2","publicId":"tmux_select:from_list/2","qualifiedName":"tmux_select:from_list/2","name":"from_list/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"from_list(Entity, Rows)\n-spec from_list(tmux_schema:entity(), [Row]) -> t(Row)\n                   when Row :: tmux_model:row().","references":[{"start":40,"end":58,"target":"t:tmux_schema:entity/0"},{"start":72,"end":73,"target":"t:tmux_select:t/1"},{"start":110,"end":124,"target":"t:tmux_model:row/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Rows","type":"[Row]","typeReferences":[]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate an ordinary list without rebinding, reordering or deduplicating it.","examples":[{"lang":"erlang","code":"1> {ok, P} = tmux_model:pane(#{id => <<\"%1\">>, width => 120}), ok.\nok\n2> S = tmux_select:from_list(pane, [P, P]), ok.\nok\n3> tmux_select:size(tmux_select:where(#{width => #{gte => 120}}, S)).\n2\n4> tmux_select:one(S).\n{error,{multiple_matches,#{at_least => 2}}}"}]},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-from_list-2"},{"id":"tmux_select:matching/2","publicId":"tmux_select:matching/2","qualifiedName":"tmux_select:matching/2","name":"matching/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"matching/2\n-spec matching({module(), term()}, t(Row)) ->\n                  {ok, t(Row)} | {error, term()}\n                  when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:module/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:module/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":37,"end":41,"target":"t:erlang:term/0"},{"start":46,"end":47,"target":"t:tmux_select:t/1"},{"start":80,"end":81,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":98,"end":102,"target":"t:erlang:term/0"},{"start":136,"end":150,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"{module(), term()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:module/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:module/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":11,"end":15,"target":"t:erlang:term/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, t(Row)} | {error, term()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Prepare a trusted behaviour once, then apply its Boolean predicate.","body":"Uses `c:tmux_matcher:prepare/2`; preparation failure returns {error, Detail}.\nExceptions in either callback propagate. A matcher requires a captured\nsnapshot; a `from_list/2` selection returns matcher_requires_snapshot. The\napplication chooses Module."},"source":{"line":154,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-matching-2"},{"id":"tmux_select:one/1","publicId":"tmux_select:one/1","qualifiedName":"tmux_select:one/1","name":"one/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one/1\n-spec one(t(Row)) -> {ok, Row} | cardinality_error()\n             when Row :: tmux_model:row().","references":[{"start":16,"end":17,"target":"t:tmux_select:t/1"},{"start":39,"end":56,"target":"t:tmux_select:cardinality_error/0"},{"start":84,"end":98,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | cardinality_error()","returnsReferences":[{"start":12,"end":29,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole current row or a no_match/multiple_matches error. Ambiguity reports at_least = 2 rather than computing a needless exact count."},"source":{"line":233,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one-1"},{"id":"tmux_select:one/2","publicId":"tmux_select:one/2","qualifiedName":"tmux_select:one/2","name":"one/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one(Criteria, Selection)\n-spec one(criteria(), t(Row)) ->\n             {ok, Row} | cardinality_error()\n             when Row :: tmux_model:row().","references":[{"start":35,"end":43,"target":"t:tmux_select:criteria/0"},{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":83,"end":100,"target":"t:tmux_select:cardinality_error/0"},{"start":128,"end":142,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | cardinality_error()","returnsReferences":[{"start":12,"end":29,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria and coverage, then stop after enough local matches to establish cardinality. Returns a tagged cardinality result; performs no I/O."},"source":{"line":241,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one-2"},{"id":"tmux_select:one_or_error/1","publicId":"tmux_select:one_or_error/1","qualifiedName":"tmux_select:one_or_error/1","name":"one_or_error/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_error(Selection)\n-spec one_or_error(t(Row)) -> Row\n                      when Row :: tmux_model:row().","references":[{"start":43,"end":44,"target":"t:tmux_select:t/1"},{"start":92,"end":106,"target":"t:tmux_model:row/0"}],"params":[{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Row","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole row directly, raising on zero or multiple matches. Use `one/1` for tagged cardinality errors."},"source":{"line":262,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one_or_error-1"},{"id":"tmux_select:one_or_error/2","publicId":"tmux_select:one_or_error/2","qualifiedName":"tmux_select:one_or_error/2","name":"one_or_error/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_error(Criteria, Selection)\n-spec one_or_error(criteria(), t(Row)) -> Row\n                      when Row :: tmux_model:row().","references":[{"start":53,"end":61,"target":"t:tmux_select:criteria/0"},{"start":65,"end":66,"target":"t:tmux_select:t/1"},{"start":114,"end":128,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Row","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Filter locally with complete validation, then return the sole row directly. Raises on zero or multiple matches; performs no I/O."},"source":{"line":273,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one_or_error-2"},{"id":"tmux_select:one_or_none/1","publicId":"tmux_select:one_or_none/1","qualifiedName":"tmux_select:one_or_none/1","name":"one_or_none/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_none(Selection)\n-spec one_or_none(t(Row)) ->\n                     {ok, Row | none} | cardinality_error()\n                     when Row :: tmux_model:row().","references":[{"start":41,"end":42,"target":"t:tmux_select:t/1"},{"start":92,"end":109,"target":"t:tmux_select:cardinality_error/0"},{"start":145,"end":159,"target":"t:tmux_model:row/0"}],"params":[{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row | none} | cardinality_error()","returnsReferences":[{"start":19,"end":36,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole current row, {ok, none} on absence, or a multiple-match error. Performs no I/O."},"source":{"line":248,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one_or_none-1"},{"id":"tmux_select:one_or_none/2","publicId":"tmux_select:one_or_none/2","qualifiedName":"tmux_select:one_or_none/2","name":"one_or_none/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_none(Criteria, Selection)\n-spec one_or_none(criteria(), t(Row)) ->\n                     {ok, Row | none} | cardinality_error()\n                     when Row :: tmux_model:row().","references":[{"start":51,"end":59,"target":"t:tmux_select:criteria/0"},{"start":63,"end":64,"target":"t:tmux_select:t/1"},{"start":114,"end":131,"target":"t:tmux_select:cardinality_error/0"},{"start":167,"end":181,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row | none} | cardinality_error()","returnsReferences":[{"start":19,"end":36,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate local criteria and return one row or known absence. A second match is an explicit ambiguity error; performs no I/O."},"source":{"line":255,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-one_or_none-2"},{"id":"tmux_select:panes/1","publicId":"tmux_select:panes/1","qualifiedName":"tmux_select:panes/1","name":"panes/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Snapshot)\n-spec panes(tmux_snapshot:t()) -> t(tmux_model:pane()).","references":[{"start":28,"end":43,"target":"t:tmux_snapshot:t/0"},{"start":50,"end":51,"target":"t:tmux_select:t/1"},{"start":52,"end":67,"target":"t:tmux_model:pane/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:pane())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":17,"target":"t:tmux_model:pane/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select captured physical panes while retaining snapshot graph and coverage. Performs no I/O and preserves the snapshot's deterministic order."},"source":{"line":64,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-panes-1"},{"id":"tmux_select:sessions/1","publicId":"tmux_select:sessions/1","qualifiedName":"tmux_select:sessions/1","name":"sessions/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Snapshot)\n-spec sessions(tmux_snapshot:t()) ->\n                  t(tmux_model:session()).","references":[{"start":34,"end":49,"target":"t:tmux_snapshot:t/0"},{"start":74,"end":75,"target":"t:tmux_select:t/1"},{"start":76,"end":94,"target":"t:tmux_model:session/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:session())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":20,"target":"t:tmux_model:session/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select captured sessions with their relationship and coverage context. Performs no I/O."},"source":{"line":82,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-sessions-1"},{"id":"tmux_select:size/1","publicId":"tmux_select:size/1","qualifiedName":"tmux_select:size/1","name":"size/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"size/1\n-spec size(t()) -> non_neg_integer().","references":[{"start":18,"end":19,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":26,"end":41,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the cached number of materialized rows in this selection without traversing tmux or re-evaluating criteria."},"source":{"line":192,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-size-1"},{"id":"tmux_select:summary/1","publicId":"tmux_select:summary/1","qualifiedName":"tmux_select:summary/1","name":"summary/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"summary/1\n-spec summary(t()) -> summary().","references":[{"start":24,"end":25,"target":"t:tmux_select:t/0"},{"start":32,"end":39,"target":"t:tmux_select:summary/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"summary()","returnsReferences":[{"start":0,"end":7,"target":"t:tmux_select:summary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a compact Erlang diagnostic map with entity, size, capture identity, interval and coverage. Fetched queries include candidate/attempt information. Opaque snapshot references make this a diagnostic value, not a wire format."},"source":{"line":200,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-summary-1"},{"id":"tmux_select:take/2","publicId":"tmux_select:take/2","qualifiedName":"tmux_select:take/2","name":"take/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"take/2\n-spec take(non_neg_integer(), t(Row)) -> t(Row)\n              when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":18,"end":33,"target":"t:erlang:non_neg_integer/0"},{"start":37,"end":38,"target":"t:tmux_select:t/1"},{"start":48,"end":49,"target":"t:tmux_select:t/1"},{"start":81,"end":95,"target":"t:tmux_model:row/0"}],"params":[{"name":"Count","type":"non_neg_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Keep the first N rows and retain the original observation and coverage. Performs no I/O; taking a subset cannot establish missing field coverage."},"source":{"line":185,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-take-2"},{"id":"tmux_select:to_list/1","publicId":"tmux_select:to_list/1","qualifiedName":"tmux_select:to_list/1","name":"to_list/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"to_list/1\n-spec to_list(t(Row)) -> [Row] when Row :: tmux_model:row().","references":[{"start":24,"end":25,"target":"t:tmux_select:t/1"},{"start":53,"end":67,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"[Row]","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the current ordered rows as an ordinary Erlang list without I/O. Use list functions or comprehensions for transformations to other value types. Returns the stored rows without copying their binary fields. Keeping only the list allows the selection's snapshot context to be collected; other references can still keep that context alive."},"source":{"line":173,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-to_list-1"},{"id":"tmux_select:try_where/2","publicId":"tmux_select:try_where/2","qualifiedName":"tmux_select:try_where/2","name":"try_where/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"try_where/2\n-spec try_where(criteria(), t(Row)) ->\n                   {ok, t(Row)} | {error, map()}\n                   when Row :: tmux_model:row().","references":[{"start":28,"end":36,"target":"t:tmux_select:criteria/0"},{"start":40,"end":41,"target":"t:tmux_select:t/1"},{"start":75,"end":76,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"start":131,"end":145,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, t(Row)} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":23,"end":26,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Apply the same local criteria and coverage checks as `where/2`, returning tagged validation or evaluation errors. It does not catch arbitrary application callback exceptions and never performs tmux I/O."},"source":{"line":129,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-try_where-2"},{"id":"tmux_select:where/2","publicId":"tmux_select:where/2","qualifiedName":"tmux_select:where/2","name":"where/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"where(Criteria, Selection)\n-spec where(criteria(), t(Row)) -> t(Row)\n               when Row :: tmux_model:row().","references":[{"start":39,"end":47,"target":"t:tmux_select:criteria/0"},{"start":51,"end":52,"target":"t:tmux_select:t/1"},{"start":62,"end":63,"target":"t:tmux_select:t/1"},{"start":96,"end":110,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate portable criteria and coverage, then preserve matching rows in order. Performs no I/O. Malformed trusted criteria raise bad_filter; missing coverage and runtime evaluation failures remain distinct exceptions. Use `try_where/2` for tagged library errors."},"source":{"line":117,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-where-2"},{"id":"tmux_select:window_links/1","publicId":"tmux_select:window_links/1","qualifiedName":"tmux_select:window_links/1","name":"window_links/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Snapshot)\n-spec window_links(tmux_snapshot:t()) ->\n                      t(tmux_model:window_link()).","references":[{"start":42,"end":57,"target":"t:tmux_snapshot:t/0"},{"start":86,"end":87,"target":"t:tmux_select:t/1"},{"start":88,"end":110,"target":"t:tmux_model:window_link/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:window_link())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":24,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select all captured session memberships, retaining repeated physical windows and session-relative indexes. Performs no I/O."},"source":{"line":76,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-window_links-1"},{"id":"tmux_select:windows/1","publicId":"tmux_select:windows/1","qualifiedName":"tmux_select:windows/1","name":"windows/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Snapshot)\n-spec windows(tmux_snapshot:t()) -> t(tmux_model:window()).","references":[{"start":32,"end":47,"target":"t:tmux_snapshot:t/0"},{"start":54,"end":55,"target":"t:tmux_select:t/1"},{"start":56,"end":73,"target":"t:tmux_model:window/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:window())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":19,"target":"t:tmux_model:window/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select unique captured physical windows with their complete graph context. Performs no I/O; session memberships remain separate window-link rows."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_select-windows-1"},{"id":"t:tmux_select:cardinality_error/0","publicId":"t:tmux_select:cardinality_error/0","qualifiedName":"tmux_select:cardinality_error/0","name":"cardinality_error/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type cardinality_error() ::\n          {error,\n           no_match | {multiple_matches, #{at_least := 2}}}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"supporting","source":{"line":47,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_select-cardinality_error-0"},{"id":"t:tmux_select:criteria/0","publicId":"t:tmux_select:criteria/0","qualifiedName":"tmux_select:criteria/0","name":"criteria/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type criteria() :: map() | tmux_filter:t().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"start":28,"end":41,"target":"t:tmux_filter:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"supporting","source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_select-criteria-0"},{"id":"t:tmux_select:summary/0","publicId":"t:tmux_select:summary/0","qualifiedName":"tmux_select:summary/0","name":"summary/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type summary() ::\n          #{entity := tmux_schema:entity(),\n            size := non_neg_integer(),\n            snapshot_id := reference() | none,\n            coverage := tmux_snapshot:entity_coverage(),\n            capture_started => integer(),\n            capture_finished => integer(),\n            time_unit => microsecond,\n            query => tmux_snapshot:query_metadata()}.","params":[],"references":[{"start":41,"end":59,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":83,"end":98,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":129,"end":138,"target":"t:erlang:reference/0"},{"start":173,"end":202,"target":"t:tmux_snapshot:entity_coverage/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":237,"end":244,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":280,"end":287,"target":"t:erlang:integer/0"},{"start":350,"end":378,"target":"t:tmux_snapshot:query_metadata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Compact local inspection. size counts current materialized rows; coverage still describes the original captured context after filtering or take. snapshot_id is none for a list-backed selection. Capture bounds and query diagnostics are included only when that source metadata exists."},"source":{"line":54,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_select-summary-0"},{"id":"t:tmux_select:t/0","publicId":"t:tmux_select:t/0","qualifiedName":"tmux_select:t/0","name":"t/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type t() :: t(tmux_model:row()).","params":[],"references":[{"start":13,"end":14,"target":"t:tmux_select:t/1"},{"start":15,"end":29,"target":"t:tmux_model:row/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A selection over schema-defined native domain records."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_select-t-0"},{"id":"t:tmux_select:t/1","publicId":"t:tmux_select:t/1","qualifiedName":"tmux_select:t/1","name":"t/1","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t(Row).","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Ordered captured rows with observation and coverage context, not an extensible list protocol. The parameter describes the intended row type. OTP 29 Dialyzer can widen generic return variables to their declared bounds; it does not prove every entity relationship through `one/1` or `to_list/1`. Runtime schema, coverage and action checks remain necessary."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_select-t-1"},{"id":"tmux_server","publicId":"tmux_server","qualifiedName":"tmux_server","name":"tmux_server","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Open tmux endpoints and execute explicit command values.","body":"`open/1` validates an absolute socket path and the\nexecutable/server versions. It never creates a tmux server or attaches a\ncontrol client. Each command rechecks the observed Linux process incarnation\nbefore dispatch. Replacement between that observation and a later client\nconnection remains possible; same_connection requests are rejected until\npersistent dispatch qualifies.\n\n`start_owned/1` creates a separate private daemon and returns an ownership\ntoken for `stop_owned/1`. The [ownership guide](ownership.md) explains caller\ndeath, application shutdown and namespace cleanup.\n\nUse `with_server/2` or `with_owned/2` for a callback scope. They attempt cleanup\nafter its return or exception and preserve both outcomes if cleanup fails.\n\nThe calling process owns the endpoint. `close/1` cancels queued\nwork, retires its one-shot clients and preserves the borrowed server. Cleanup\nfailure remains explicit and keeps the supervised owner alive. Successful close is\nidempotent during the 60-second handle retention period. Separate\n`m:tmux_control` attachments receive an invalidation notice and begin their\nown retirement. Close those attachments explicitly to prove their native\ncleanup. Command results preserve stdout, stderr and status; cancellation\nafter dispatch cannot undo\nremote effects. Clients explicitly select tmux's UTF-8 mode so Unicode and the\nidentity probe's tab do not depend on the caller's locale. Command-specific\nescaping still applies to raw command output.\n\nUse `snapshot/1` to capture a graph for `m:tmux_snapshot` and\n`m:tmux_select`. Use `m:tmux_operation` for non-blocking submission and\nexplicit waits; the [job guide](jobs.md) explains ownership and cleanup."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server"},{"id":"tmux_server:bind/2","publicId":"tmux_server:bind/2","qualifiedName":"tmux_server:bind/2","name":"bind/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Row)\n-spec bind(t(), tmux_model:row()) ->\n              {ok, tmux_model:row()} | {error, map()}.","references":[{"start":29,"end":30,"target":"t:tmux_server:t/0"},{"start":34,"end":48,"target":"t:tmux_model:row/0"},{"start":74,"end":88,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":102,"end":105,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]}],"returns":"{ok, tmux_model:row()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicitly read current fields from this server and register the new value. For sessions, physical windows and panes, the read uses the stable ID and discards the supplied field observations. This explicit call accepts an edited target; ordinary actions require its captured target association to match and reject mismatches before dispatch. The returned row carries a new private observation association; see `m:tmux_model`. It provides no atomic identity check. Window-link binding checks its session/index and expected physical window. A replaced or missing membership returns stale_link. This observed preflight does not make a later action atomic.","body":"Invalid rows are rejected before I/O:","examples":[{"lang":"erlang","code":"1> tmux_server:bind(invalid_server, invalid_row).\n{error,#{code => invalid_row,path => []}}"}]},"source":{"line":350,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-bind-2"},{"id":"tmux_server:close/1","publicId":"tmux_server:close/1","qualifiedName":"tmux_server:close/1","name":"close/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"close(Server)\n-spec close(t()) -> ok | {error, map()}.","references":[{"start":26,"end":27,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":47,"end":50,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Retire this endpoint's operations and one-shot clients, preserving the borrowed tmux server. Returns ok only after their cleanup completes; incomplete cleanup remains an explicit error. Closing an already closed retained handle is idempotent. The initiator controls endpoint lifetime. Separate control attachments are invalidated and asked to retire; use `tmux_control:close/1` before this call to verify those clients' cleanup too."},"source":{"line":267,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-close-1"},{"id":"tmux_server:command/3","publicId":"tmux_server:command/3","qualifiedName":"tmux_server:command/3","name":"command/3","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"command(Server, Command, Options)\n-spec command(t(), tmux_command:t(), command_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":48,"end":49,"target":"t:tmux_server:t/0"},{"start":53,"end":67,"target":"t:tmux_command:t/0"},{"start":71,"end":86,"target":"t:tmux_server:command_options/0"},{"start":115,"end":139,"target":"t:tmux_operation:completed/0"},{"start":170,"end":192,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Command","type":"tmux_command:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"command_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_server:command_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute one validated command and await its result. Performs I/O. The result preserves stdout, stderr, exit status and cleanup certainty. Use `tmux_operation:start/3` to submit without blocking this caller. A timeout or cancellation cannot reverse effects that may already have reached tmux. Values from domain command builders keep their captured endpoint origin. Another endpoint returns different_owner with submitted = false before any native preflight or execution. Raw commands do not carry that origin."},"source":{"line":252,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-command-3"},{"id":"tmux_server:open/1","publicId":"tmux_server:open/1","qualifiedName":"tmux_server:open/1","name":"open/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"open(Options)\n-spec open(open_options()) -> {ok, t()} | {error, map()}.","references":[{"start":25,"end":37,"target":"t:tmux_server:open_options/0"},{"start":49,"end":50,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":64,"end":67,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"open_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_server:open_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Open a borrowed socket endpoint and start its supervised library owner. The caller owns that handle. This probes the executable, daemon version and observed Linux process incarnation; it never starts a tmux server or attaches a control client. Pass an absolute socket_path and optionally an executable."},"source":{"line":114,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-open-1"},{"id":"tmux_server:origin/1","publicId":"tmux_server:origin/1","qualifiedName":"tmux_server:origin/1","name":"origin/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"origin(Server)\n-spec origin(t()) -> {ok, reference()} | {error, map()}.","references":[{"start":28,"end":29,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":41,"end":50,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":64,"end":67,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, reference()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":5,"end":14,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":28,"end":31,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the registered opaque origin for this open endpoint. The token provides library provenance and generation checks, not authorization against trusted Erlang code. It is not a portable identifier."},"source":{"line":282,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-origin-1"},{"id":"tmux_server:snapshot/1","publicId":"tmux_server:snapshot/1","qualifiedName":"tmux_server:snapshot/1","name":"snapshot/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot(Server)\n-spec snapshot(t()) ->\n                  {ok, tmux_snapshot:t()} | {error, map()}.","references":[{"start":32,"end":33,"target":"t:tmux_server:t/0"},{"start":63,"end":78,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, tmux_snapshot:t()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture a complete immutable graph with default capture limits. Performs I/O. See `snapshot/2` for bounds, consistency and conflict errors."},"source":{"line":297,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-snapshot-1"},{"id":"tmux_server:snapshot/2","publicId":"tmux_server:snapshot/2","qualifiedName":"tmux_server:snapshot/2","name":"snapshot/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot(Server, Options)\n-spec snapshot(t(), capture_options()) ->\n                  {ok, tmux_snapshot:t()} | {error, map()}.","references":[{"start":41,"end":42,"target":"t:tmux_server:t/0"},{"start":46,"end":61,"target":"t:tmux_server:capture_options/0"},{"start":91,"end":106,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":120,"end":123,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"capture_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_server:capture_options/0"}]}],"returns":"{ok, tmux_snapshot:t()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture the server's sessions, physical windows, window links and panes.","body":"This performs explicit I/O and records each command's observation interval.\nIdentity scans bracket field reads; detected topology or value disagreements\nreturn inconsistent_capture. Changes between reads can remain undetected,\nincluding changes followed by a reversal. Atomic capture is unsupported.\n\nOptions are consistency (observed only), deadline_ms (default 2500, maximum\n600000), max_rows (4096, maximum 65536 raw observations per scan and aggregate\nspine) and max_bytes (8 MiB, maximum 64 MiB total stdout across capture\ncommands). Repeated memberships count before deduplication. The\n`t:hydration/0` strategy defaults to batched. Each command is limited to 1 MiB;\nisolated hydration distributes larger entity output across individual fields.\nThese are data limits, not a VM heap limit. Capturing performs no retry. Local\nreads of the resulting value do no I/O. `tmux_snapshot:metadata/1` records the\nstrategy and actual source calls.\n\nUnsupported consistency is rejected before contacting a server:","examples":[{"lang":"erlang","code":"1> tmux_server:snapshot(invalid_server, #{consistency => atomic}).\n{error,#{code => unsupported_consistency}}"}]},"source":{"line":325,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-snapshot-2"},{"id":"tmux_server:start_owned/1","publicId":"tmux_server:start_owned/1","qualifiedName":"tmux_server:start_owned/1","name":"start_owned/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"start_owned(Options)\n-spec start_owned(owned_options()) ->\n                     {ok, t(), ownership()} |\n                     {error, map()}.","references":[{"start":39,"end":52,"target":"t:tmux_server:owned_options/0"},{"start":85,"end":86,"target":"t:tmux_server:t/0"},{"start":90,"end":99,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":134,"end":137,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"owned_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:owned_options/0"}]}],"returns":"{ok, t(), ownership()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"},{"start":10,"end":19,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Start an empty owned daemon in a fresh private Linux socket directory. Performs I/O and waits for bounded startup; no session or attached observer is created. Returns an ordinary endpoint and a separate `t:ownership/0` token. The caller owns the daemon lifetime: caller death or `stop_owned/1` retires its helper tree. `close/1` only closes the endpoint and preserves the daemon.","body":"The daemon starts without a user config, with `exit-empty` disabled. One idle,\nunattached bootstrap client keeps the owned helper tree alive. Startup includes\nreadiness and endpoint incarnation binding, not just executable launch.\nIncomplete cleanup remains explicit; it is never permission to kill by path.\nAn incomplete startup error includes an ownership token and captured resources\nfor `stop_owned/1` recovery. The token does not serialize across VM lifetimes."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-start_owned-1"},{"id":"tmux_server:status/1","publicId":"tmux_server:status/1","qualifiedName":"tmux_server:status/1","name":"status/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"status(Server)\n-spec status(t()) ->\n                {ok, state()} |\n                {error, tmux_operation:failure()}.","references":[{"start":28,"end":29,"target":"t:tmux_server:t/0"},{"start":57,"end":62,"target":"t:tmux_server:state/0"},{"start":92,"end":114,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, state()} | {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_server:state/0"},{"start":24,"end":46,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the endpoint owner's lifecycle and resource summary. This contacts the library owner, not tmux, and does not refresh captured rows."},"source":{"line":274,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-status-1"},{"id":"tmux_server:stop_owned/1","publicId":"tmux_server:stop_owned/1","qualifiedName":"tmux_server:stop_owned/1","name":"stop_owned/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"stop_owned(Ownership)\n-spec stop_owned(ownership()) -> ok | {error, map()}.","references":[{"start":39,"end":48,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":68,"end":71,"target":"t:erlang:map/0"}],"params":[{"name":"Ownership","type":"ownership()","typeReferences":[{"start":0,"end":9,"target":"t:tmux_server:ownership/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Stop the daemon and endpoint associated with a `t:ownership/0` token. Performs I/O and returns ok only after endpoint/client/helper retirement and namespace cleanup are proved. It never sends kill-server to a socket path.","body":"A replaced socket/directory or unexpected directory contents are preserved and\nreturn `cleanup_incomplete` with process and namespace details. A supervised\ntombstone retains uncertain cleanup; call again to inspect/retry after external\nrepair. Filesystem identity checks are observations, not atomic reservations\nagainst another trusted process replacing a path during unlink.\n\nSuccessful stop is idempotent during the 60-second token retention period.\nAfter token expiry or application shutdown, returns `ownership_expired`.\nStop explicitly before application shutdown when the caller needs a verified\ncleanup result. OTP application shutdown itself does not prove native cleanup.\nIncomplete shutdown writes a private recovery report outside the owned socket\ndirectory and logs its location or write failure; no automatic recovery runs."},"source":{"line":163,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-stop_owned-1"},{"id":"tmux_server:version/1","publicId":"tmux_server:version/1","qualifiedName":"tmux_server:version/1","name":"version/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"version(Server)\n-spec version(t()) ->\n                 {ok, tmux_version:t()} | {error, map()}.","references":[{"start":30,"end":31,"target":"t:tmux_server:t/0"},{"start":60,"end":74,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":88,"end":91,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, tmux_version:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the daemon version observed when the endpoint opened. This reads owner state and does not execute a fresh version command or qualify another tmux release."},"source":{"line":290,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-version-1"},{"id":"tmux_server:with_owned/2","publicId":"tmux_server:with_owned/2","qualifiedName":"tmux_server:with_owned/2","name":"with_owned/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"with_owned(Options, Function)\n-spec with_owned(owned_options(), fun((t()) -> Value)) ->\n                    {ok, Value} |\n                    {error, scope_failure() | map()}.","references":[{"start":47,"end":60,"target":"t:tmux_server:owned_options/0"},{"start":69,"end":70,"target":"t:tmux_server:t/0"},{"start":150,"end":163,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":168,"end":171,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"owned_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:owned_options/0"}]},{"name":"Function","type":"fun((t()) -> Value)","typeReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, Value} | {error, scope_failure() | map()}","returnsReferences":[{"start":22,"end":35,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Start an owned daemon, run a callback in the calling process, then stop it. Performs `start_owned/1` and token-based `stop_owned/1` around the callback. With successful cleanup, returns {ok, Value} or re-raises the original callback exception. A returned error tuple is an ordinary callback value. Startup failure passes through without invoking the callback.","body":"Cleanup failure returns `t:scope_failure/0`, including both server and ownership\nhandles for inspection and an explicit stop retry. It preserves the callback\noutcome and cleanup evidence separately; it never claims timeout is retirement.\nSee `with_server/2` for callback and separately allocated resource obligations."},"source":{"line":204,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-with_owned-2"},{"id":"tmux_server:with_server/2","publicId":"tmux_server:with_server/2","qualifiedName":"tmux_server:with_server/2","name":"with_server/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"with_server(Options, Function)\n-spec with_server(open_options(), fun((t()) -> Value)) ->\n                     {ok, Value} |\n                     {error, scope_failure() | map()}.","references":[{"start":49,"end":61,"target":"t:tmux_server:open_options/0"},{"start":70,"end":71,"target":"t:tmux_server:t/0"},{"start":153,"end":166,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":171,"end":174,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"open_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_server:open_options/0"}]},{"name":"Function","type":"fun((t()) -> Value)","typeReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, Value} | {error, scope_failure() | map()}","returnsReferences":[{"start":22,"end":35,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Open a borrowed endpoint, run a callback in the calling process, then close it. Performs the same I/O as `open/1` and `close/1`; the borrowed daemon survives. Startup failure passes through without invoking the callback.","body":"With successful cleanup, returns {ok, Value} for any callback return value,\nincluding a returned error tuple. Callback error, throw and exit exceptions\nare re-raised with their original reason and stack. If cleanup fails, returns\n{error, Failure} with `t:scope_failure/0`, preserving both outcomes and the\nendpoint for explicit recovery. It attempts cleanup once; a timeout does not\nprove retirement. Existing supervised cleanup ownership remains in force.\n\nThe callback must retire separately created resources such as `m:tmux_control`\nattachments. This scope closes its endpoint, not every resource the callback\nmay allocate. Use `with_owned/2` when the scope should own the daemon too."},"source":{"line":183,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_server-with_server-2"},{"id":"t:tmux_server:capture_options/0","publicId":"t:tmux_server:capture_options/0","qualifiedName":"tmux_server:capture_options/0","name":"capture_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capture_options() ::\n          #{deadline_ms => 1..600000,\n            max_rows => 1..65536,\n            max_bytes => 1..67108864,\n            hydration => hydration(),\n            consistency => observed | atomic}.","params":[],"references":[{"start":162,"end":171,"target":"t:tmux_server:hydration/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture bounds, hydration strategy and consistency request. Atomic capture is unsupported."},"source":{"line":85,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-capture_options-0"},{"id":"t:tmux_server:command_options/0","publicId":"t:tmux_server:command_options/0","qualifiedName":"tmux_server:command_options/0","name":"command_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_options() ::\n          #{deadline_ms => 1..600000,\n            max_stdout => 0..1048576,\n            max_stderr => 0..65536,\n            stdin => binary(),\n            identity => observed | same_connection}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Command options: deadline_ms defaults to 2500, max_stdout to 1 MiB, max_stderr to 64 KiB, stdin to an empty binary and identity to observed. The deadline includes admission, preflight and execution. stdin is limited to 256 KiB; stdin plus the rendered argument reservation must also fit 256 KiB. Each endpoint admits at most 64 operations and 256 KiB of command payload; exhaustion returns busy. same_connection is recognized but unsupported."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-command_options-0"},{"id":"t:tmux_server:hydration/0","publicId":"t:tmux_server:hydration/0","qualifiedName":"tmux_server:hydration/0","name":"hydration/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type hydration() :: batched | isolated.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture text/bytes with one framed scan per entity (batched, the default), or one field per physical row (isolated). Both retain complete graph coverage and interval semantics. Each command has the same 1 MiB stdout bound; isolated can distribute large entity output across commands at greater source cost. See `snapshot/2` and `tmux_query:explain/1`."},"source":{"line":83,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-hydration-0"},{"id":"t:tmux_server:open_options/0","publicId":"t:tmux_server:open_options/0","qualifiedName":"tmux_server:open_options/0","name":"open_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type open_options() ::\n          #{socket_path := binary(),\n            executable => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":51,"end":57,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":87,"end":93,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An explicit absolute socket endpoint and optional absolute tmux executable path."},"source":{"line":58,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-open_options-0"},{"id":"t:tmux_server:owned_options/0","publicId":"t:tmux_server:owned_options/0","qualifiedName":"tmux_server:owned_options/0","name":"owned_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type owned_options() ::\n          #{executable => binary(),\n            startup_timeout_ms => 1..600000}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":51,"end":57,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Owned startup options. The finite startup budget defaults to 2500 milliseconds."},"source":{"line":60,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-owned_options-0"},{"id":"t:tmux_server:ownership/0","publicId":"t:tmux_server:ownership/0","qualifiedName":"tmux_server:ownership/0","name":"ownership/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque ownership().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Opaque ownership token for `stop_owned/1`. An ordinary endpoint or row origin does not convey this token. Trusted code can pass it to another process."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-ownership-0"},{"id":"t:tmux_server:scope_failure/0","publicId":"t:tmux_server:scope_failure/0","qualifiedName":"tmux_server:scope_failure/0","name":"scope_failure/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope_failure() ::\n          #{code := scope_cleanup_failed,\n            primary :=\n                {ok, term()} |\n                {exception,\n                 error | exit | throw,\n                 term(),\n                 erlang:stacktrace()},\n            cleanup :=\n                {error, map()} |\n                {exception,\n                 error | exit | throw,\n                 term(),\n                 erlang:stacktrace()},\n            server := t(),\n            ownership => ownership()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":205,"end":209,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":230,"end":247,"target":"t:erlang:stacktrace/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":299,"end":302,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":392,"end":396,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":417,"end":434,"target":"t:erlang:stacktrace/0"},{"start":461,"end":462,"target":"t:tmux_server:t/0"},{"start":491,"end":500,"target":"t:tmux_server:ownership/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Both callback and cleanup evidence when a scope cannot prove retirement. primary is the callback value or its exception class, reason and original stack. cleanup preserves the operational error or a separate cleanup exception. server permits `close/1` reconciliation; owned scopes also include ownership for `stop_owned/1`. Retain these handles until cleanup is resolved."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-scope_failure-0"},{"id":"t:tmux_server:state/0","publicId":"t:tmux_server:state/0","qualifiedName":"tmux_server:state/0","name":"state/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := open | closing | closed,\n            generation := reference(),\n            owner := pid(),\n            operations := non_neg_integer(),\n            command_bytes := non_neg_integer(),\n            active_bytes := non_neg_integer(),\n            retained_results := non_neg_integer(),\n            result_bytes := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":89,"end":98,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":123,"end":126,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":156,"end":171,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":204,"end":219,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":251,"end":266,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":302,"end":317,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":349,"end":364,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Endpoint resource summary. owner is the supervised endpoint process, not its initiating caller. operations and command_bytes count active admission leases; active_bytes reserves output capacity. Retired results are bounded separately by retained_results and result_bytes. These are accounting limits, not VM heap measurements. generation identifies this endpoint handle's lifetime."},"source":{"line":94,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-state-0"},{"id":"t:tmux_server:t/0","publicId":"t:tmux_server:t/0","qualifiedName":"tmux_server:t/0","name":"t/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A supervised borrowed-endpoint handle bound to an owner generation and admission state."},"source":{"line":103,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_server-t-0"},{"id":"tmux_session","publicId":"tmux_session","qualifiedName":"tmux_session","name":"tmux_session","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create and observe sessions, or act on a session's registered stable ID.","body":"`create/2` accepts name, window_name, width, height, cwd, env,\nlaunch and detach. Creation defaults to detached with tmux's configured\nshell/command. launch is default_shell, an argv map, or an explicit shell map.\nenv augments tmux's inherited environment. tmux supplies PATH, SHELL, PWD and\nTMUX_PANE after that merge, so those entries may be replaced. Names and cwd\nare literal format values; tmux's stored name rules still apply. Creation\nnever adopts an existing session by name.\n\nAn empty shell command can exit immediately and remove its session. It does\nnot request the empty-pane behavior of split-window. Use a running program\nwhen later operations require the session to remain alive.\n\n`create/2` and `get/2` explicitly read the\nnew/current row through several one-shot commands. These reads are not atomic.\nIf creation succeeds but observation fails, the error retains mutation =\ncompleted and the original command result. `rename/2` and\n`kill/1` return command results without refreshing the input\nrecord. Detached rows require `tmux_server:bind/2` before actions.\n`rename_command/2` builds a reusable value without tmux I/O; the other calls\nperform I/O after validation.\n\n`select/2` switches one explicitly named attached client to a session. It\nnever attaches a client or infers the current client. Use\n`tmux_window_link:select/1` to select a session's window membership instead."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session"},{"id":"tmux_session:create/2","publicId":"tmux_session:create/2","qualifiedName":"tmux_session:create/2","name":"create/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"create(Server, Options)\n-spec create(tmux_server:t(), create_options()) ->\n                {ok, tmux_model:session()} | {error, map()}.","references":[{"start":37,"end":50,"target":"t:tmux_server:t/0"},{"start":54,"end":68,"target":"t:tmux_session:create_options/0"},{"start":96,"end":114,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":128,"end":131,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"create_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_session:create_options/0"}]}],"returns":"{ok, tmux_model:session()} | {error, map()}","returnsReferences":[{"start":5,"end":23,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":37,"end":40,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Create a detached session by default and explicitly observe the returned row. Options include name, window_name, dimensions, cwd, env and launch. Performs I/O; an observation failure after successful creation retains mutation = completed and the original command result. Existing names are not adopted."},"source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-create-2"},{"id":"tmux_session:get/2","publicId":"tmux_session:get/2","qualifiedName":"tmux_session:get/2","name":"get/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:session_id()) ->\n             {ok, tmux_model:session()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":64,"target":"t:tmux_model:session_id/0"},{"start":89,"end":107,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":121,"end":124,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:session_id()","typeReferences":[{"start":0,"end":21,"target":"t:tmux_model:session_id/0"}]}],"returns":"{ok, tmux_model:session()} | {error, map()}","returnsReferences":[{"start":5,"end":23,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":37,"end":40,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read fresh session fields through explicit one-shot commands. The session ID is stable within the observed server incarnation. Returns target_gone when tmux no longer has that session; it never refreshes an existing record."},"source":{"line":64,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-get-2"},{"id":"tmux_session:kill/1","publicId":"tmux_session:kill/1","qualifiedName":"tmux_session:kill/1","name":"kill/1","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Session)\n-spec kill(tmux_model:session()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":25,"end":43,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":69,"end":72,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":86,"end":89,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy this registered session. Performs I/O and returns the command result; this is a destructive session action, not endpoint cleanup. References must belong to a live registered owner."},"source":{"line":170,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-kill-1"},{"id":"tmux_session:rename/2","publicId":"tmux_session:rename/2","qualifiedName":"tmux_session:rename/2","name":"rename/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Session, Name)\n-spec rename(tmux_model:session(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":35,"end":53,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":57,"end":63,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":91,"end":94,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":108,"end":111,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename the registered session using a literal name and return the command result. Performs I/O. Previously captured records keep their old names; detached or stale references fail validation before the action."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-rename-2"},{"id":"tmux_session:rename_command/2","publicId":"tmux_session:rename_command/2","qualifiedName":"tmux_session:rename_command/2","name":"rename_command/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"rename_command(Session, Name)\n-spec rename_command(tmux_model:session(), binary()) ->\n                        {ok, tmux_command:t()} |\n                        {error, map()}.","references":[{"start":51,"end":69,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":73,"end":79,"target":"t:erlang:binary/0"},{"start":115,"end":129,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":167,"end":170,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_command:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a literal rename command without tmux I/O. Validates the row and keeps its captured origin; endpoint liveness is checked during execution. Submit the value to `tmux_server:command/3` or `tmux_operation:start/3` with its original endpoint. Existing session records retain their captured name.","body":"Detached rows require `tmux_server:bind/2` first. Building a command does not\nexecute it or make a repeated mutation safe.","examples":[{"lang":"erlang","code":"1> tmux_session:rename_command(invalid_row, <<\"work\">>).\n{error,#{code => invalid_row,path => []}}"}]},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-rename_command-2"},{"id":"tmux_session:select/2","publicId":"tmux_session:select/2","qualifiedName":"tmux_session:select/2","name":"select/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"select(Session, Client)\n-spec select(tmux_model:session(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":37,"end":55,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":59,"end":65,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":110,"end":113,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Client","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Switch an explicitly named attached client to this registered session, preserving the session environment. Performs I/O. See `select/3` for client lookup, environment updates and disconnection races.","body":"An empty client name cannot select an implicit current client:","examples":[{"lang":"erlang","code":"1> tmux_session:select(invalid_session, <<>>).\n{error,#{code => invalid_client,path => [client]}}"}]},"source":{"line":113,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-select-2"},{"id":"tmux_session:select/3","publicId":"tmux_session:select/3","qualifiedName":"tmux_session:select/3","name":"select/3","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"select(Session, Client, Options)\n-spec select(tmux_model:session(),\n             binary(),\n             select_options()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":46,"end":64,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":81,"end":87,"target":"t:erlang:binary/0"},{"start":104,"end":118,"target":"t:tmux_session:select_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":146,"end":149,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":163,"end":166,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Client","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"select_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_session:select_options/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Switch one attached client, selected by its literal native client name or TTY path, to the session's registered stable ID. Performs I/O and returns the command result; existing rows remain captured values. Obtain the name from the caller's own client context, such as tmux's `client_name` format. There is no default client and this call never attaches one.","body":"`update_environment` defaults to false (`switch-client -E`). When true, tmux\nupdates the destination session environment using its `update-environment`\noption and that client's environment; listed variables absent from the client\ncan be marked for removal. Running pane processes retain their environment.\n\nNames are nonempty NUL-free binaries of at most 32 KiB. Trailing-colon aliases\nare rejected. Native lookup matches an exact name or TTY path, including its\n`/dev/`-relative alias; there is no prefix or pattern matching. A disconnected\nname returns `client_not_found`. Names and TTY paths can be reused by a later\nconnection; this API does not identify a client incarnation atomically. A\nmissing destination returns `target_gone`. See `tmux_server:bind/2` for detached\nsession rows and `tmux_window_link:select/1` for window selection."},"source":{"line":137,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_session-select-3"},{"id":"t:tmux_session:create_options/0","publicId":"t:tmux_session:create_options/0","qualifiedName":"tmux_session:create_options/0","name":"create_options/0","namespace":"tmux_session","parent":"tmux_session","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type create_options() ::\n          #{name => binary(),\n            window_name => binary(),\n            width => 1..65535,\n            height => 1..65535,\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":83,"end":89,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":175,"end":181,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":206,"end":212,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":218,"end":224,"target":"t:erlang:binary/0"},{"start":251,"end":275,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":301,"end":308,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Session creation options. Launch defaults to the configured shell; creation defaults to detached."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_session-create_options-0"},{"id":"t:tmux_session:select_options/0","publicId":"t:tmux_session:select_options/0","qualifiedName":"tmux_session:select_options/0","name":"select_options/0","namespace":"tmux_session","parent":"tmux_session","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type select_options() ::\n          #{update_environment => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":60,"end":67,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Session selection options. update_environment defaults to false, preserving the destination environment."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_session-select_options-0"},{"id":"tmux_snapshot","publicId":"tmux_snapshot","qualifiedName":"tmux_snapshot","name":"tmux_snapshot","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Read an immutable captured graph without performing tmux I/O.","body":"Server-wide lists use numeric ID order. Window links retain every membership,\nincluding multiple indexes for the same window in one session. Session windows\nare unique in first-link order; panes within a window use pane index order.\n`related/3` accepts a row from this snapshot and returns a\ntagged result. A row from another observation cannot silently select a\nrelationship in this one.\n\n`metadata/1` records source calls, the capture interval,\nendpoint generation and the observed server incarnation. Captures span\ncommands and are not atomic. Values remain readable after their endpoint\ncloses; actions still validate the row's registered origin. Coverage\ndistinguishes unloaded data from an empty collection and unavailable fields\nfrom known absence. See the [graph guide](graph.md) for physical windows and\nsession memberships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot"},{"id":"tmux_snapshot:coverage/1","publicId":"tmux_snapshot:coverage/1","qualifiedName":"tmux_snapshot:coverage/1","name":"coverage/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"coverage/1\n-spec coverage(t()) -> coverage().","references":[{"start":26,"end":27,"target":"t:tmux_snapshot:t/0"},{"start":34,"end":42,"target":"t:tmux_snapshot:coverage/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"coverage()","returnsReferences":[{"start":0,"end":8,"target":"t:tmux_snapshot:coverage/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return per-collection, field and relationship coverage. Loaded values, known absence, not_loaded and unavailable capabilities have distinct meanings. Performs no I/O."},"source":{"line":181,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-coverage-1"},{"id":"tmux_snapshot:get/3","publicId":"tmux_snapshot:get/3","qualifiedName":"tmux_snapshot:get/3","name":"get/3","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"get/3\n-spec get(tmux_schema:entity(), term(), t()) ->\n             {ok, tmux_model:row()} | none | {error, map()}.","references":[{"start":16,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":38,"end":42,"target":"t:erlang:term/0"},{"start":46,"end":47,"target":"t:tmux_snapshot:t/0"},{"start":72,"end":86,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":107,"end":110,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Key","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, tmux_model:row()} | none | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up a row in this capture by ID, or a session/index/window tuple for a window link. Returns none for a known missing identity and a tagged coverage error for an unloaded collection. Performs no I/O."},"source":{"line":132,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-get-3"},{"id":"tmux_snapshot:metadata/1","publicId":"tmux_snapshot:metadata/1","qualifiedName":"tmux_snapshot:metadata/1","name":"metadata/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"metadata/1\n-spec metadata(t()) -> metadata().","references":[{"start":26,"end":27,"target":"t:tmux_snapshot:t/0"},{"start":34,"end":42,"target":"t:tmux_snapshot:metadata/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"metadata()","returnsReferences":[{"start":0,"end":8,"target":"t:tmux_snapshot:metadata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return capture identity, server generation, source calls, capabilities and read interval metadata. Does not refresh the graph or imply atomic capture."},"source":{"line":174,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-metadata-1"},{"id":"tmux_snapshot:panes/1","publicId":"tmux_snapshot:panes/1","qualifiedName":"tmux_snapshot:panes/1","name":"panes/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Snapshot)\n-spec panes(t()) -> [tmux_model:pane()].","references":[{"start":28,"end":29,"target":"t:tmux_snapshot:t/0"},{"start":37,"end":52,"target":"t:tmux_model:pane/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:pane()]","returnsReferences":[{"start":1,"end":16,"target":"t:tmux_model:pane/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return unique captured physical panes in numeric ID order without I/O. `related/3` orders panes within a window by pane index."},"source":{"line":111,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-panes-1"},{"id":"tmux_snapshot:related/3","publicId":"tmux_snapshot:related/3","qualifiedName":"tmux_snapshot:related/3","name":"related/3","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"related/3\n-spec related(atom(), tmux_model:row(), t()) ->\n                 {ok,\n                  [tmux_model:row()] |\n                  tmux_model:row() |\n                  none} |\n                 {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":24,"end":28,"target":"t:erlang:atom/0"},{"start":32,"end":46,"target":"t:tmux_model:row/0"},{"start":50,"end":51,"target":"t:tmux_snapshot:t/0"},{"start":99,"end":113,"target":"t:tmux_model:row/0"},{"start":137,"end":151,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":207,"end":210,"target":"t:erlang:map/0"}],"params":[{"name":"Relation","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok,\n           [tmux_model:row()] | tmux_model:row() | none} |\n          {error, map()}","returnsReferences":[{"start":17,"end":31,"target":"t:tmux_model:row/0"},{"start":37,"end":51,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":82,"end":85,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Traverse a complete captured relationship without I/O. To-many relations return lists; to-one relations return a row or known absence. The input row must belong to this snapshot. Unloaded relations and mismatched rows return tagged errors."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-related-3"},{"id":"tmux_snapshot:require/2","publicId":"tmux_snapshot:require/2","qualifiedName":"tmux_snapshot:require/2","name":"require/2","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"require/2\n-spec require([requirement()], t()) -> ok | {error, map()}.","references":[{"start":25,"end":36,"target":"t:tmux_snapshot:requirement/0"},{"start":41,"end":42,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Requirements","type":"[requirement()]","typeReferences":[{"start":1,"end":12,"target":"t:tmux_snapshot:requirement/0"}]},{"name":"Argument2","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Check every declared collection/field/relationship requirement before local evaluation. Returns an incomplete_snapshot error with missing requirements when the capture cannot answer faithfully. Performs no I/O, even on empty data."},"source":{"line":190,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-require-2"},{"id":"tmux_snapshot:rows/2","publicId":"tmux_snapshot:rows/2","qualifiedName":"tmux_snapshot:rows/2","name":"rows/2","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"rows/2\n-spec rows(tmux_schema:entity(), t()) -> [tmux_model:row()].","references":[{"start":18,"end":36,"target":"t:tmux_schema:entity/0"},{"start":40,"end":41,"target":"t:tmux_snapshot:t/0"},{"start":49,"end":63,"target":"t:tmux_model:row/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:row()]","returnsReferences":[{"start":1,"end":15,"target":"t:tmux_model:row/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a captured collection by schema entity. Performs no I/O. An unloaded collection raises incomplete_snapshot rather than appearing empty."},"source":{"line":118,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-rows-2"},{"id":"tmux_snapshot:sessions/1","publicId":"tmux_snapshot:sessions/1","qualifiedName":"tmux_snapshot:sessions/1","name":"sessions/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Snapshot)\n-spec sessions(t()) -> [tmux_model:session()].","references":[{"start":34,"end":35,"target":"t:tmux_snapshot:t/0"},{"start":43,"end":61,"target":"t:tmux_model:session/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:session()]","returnsReferences":[{"start":1,"end":19,"target":"t:tmux_model:session/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return captured sessions in numeric ID order. Performs no I/O and raises incomplete_snapshot when that collection was not captured."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-sessions-1"},{"id":"tmux_snapshot:window_links/1","publicId":"tmux_snapshot:window_links/1","qualifiedName":"tmux_snapshot:window_links/1","name":"window_links/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Snapshot)\n-spec window_links(t()) -> [tmux_model:window_link()].","references":[{"start":42,"end":43,"target":"t:tmux_snapshot:t/0"},{"start":51,"end":73,"target":"t:tmux_model:window_link/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:window_link()]","returnsReferences":[{"start":1,"end":23,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return every captured membership, ordered by numeric session ID, index and window ID. Multiple links to the same physical window are preserved. Performs no I/O; link identity belongs to this snapshot."},"source":{"line":105,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-window_links-1"},{"id":"tmux_snapshot:windows/1","publicId":"tmux_snapshot:windows/1","qualifiedName":"tmux_snapshot:windows/1","name":"windows/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Snapshot)\n-spec windows(t()) -> [tmux_model:window()].","references":[{"start":32,"end":33,"target":"t:tmux_snapshot:t/0"},{"start":41,"end":58,"target":"t:tmux_model:window/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:window()]","returnsReferences":[{"start":1,"end":18,"target":"t:tmux_model:window/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return unique captured physical windows in numeric ID order. Performs no I/O. Use `window_links/1` for session-relative membership and indexes."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_snapshot-windows-1"},{"id":"t:tmux_snapshot:coverage/0","publicId":"t:tmux_snapshot:coverage/0","qualifiedName":"tmux_snapshot:coverage/0","name":"coverage/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type coverage() ::\n          #{tmux_schema:entity() => entity_coverage()}.","params":[],"references":[{"start":32,"end":50,"target":"t:tmux_schema:entity/0"},{"start":56,"end":71,"target":"t:tmux_snapshot:entity_coverage/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Per-entity coverage. Use `require/2` to check requirements before evaluation."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-coverage-0"},{"id":"t:tmux_snapshot:entity_coverage/0","publicId":"t:tmux_snapshot:entity_coverage/0","qualifiedName":"tmux_snapshot:entity_coverage/0","name":"entity_coverage/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type entity_coverage() ::\n          #{collection := complete | not_loaded,\n            fields :=\n                #{atom() =>\n                      loaded | not_loaded | unavailable},\n            relations :=\n                #{atom() => complete | not_loaded}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":116,"end":120,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":227,"end":231,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Collection completeness, field availability and relationship completeness. A loaded field can hold a known value or known absence; inspect the row to distinguish them. not_loaded never means empty, and unavailable never means known absence. Completeness is relative to the captured source collection."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-entity_coverage-0"},{"id":"t:tmux_snapshot:metadata/0","publicId":"t:tmux_snapshot:metadata/0","qualifiedName":"tmux_snapshot:metadata/0","name":"metadata/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type metadata() ::\n          #{id := reference(),\n            origin := reference(),\n            model_version := 2,\n            graph := complete | partial,\n            generation => reference(),\n            endpoint => #{socket_path := binary()},\n            server_instance => tmux_identity:t(),\n            tmux_version => tmux_version:t(),\n            capture_started => integer(),\n            capture_finished => integer(),\n            time_unit => microsecond,\n            source_calls => [source_call()],\n            observed_bytes => non_neg_integer(),\n            consistency => observed,\n            hydration => tmux_server:hydration(),\n            capabilities =>\n                #{field_schema := 1,\n                  identity := observed,\n                  capture := observed},\n            query => query_metadata(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":38,"end":47,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":73,"end":82,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":185,"end":194,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":239,"end":245,"target":"t:erlang:binary/0"},{"start":281,"end":296,"target":"t:tmux_identity:t/0"},{"start":328,"end":342,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":377,"end":384,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":420,"end":427,"target":"t:erlang:integer/0"},{"start":498,"end":509,"target":"t:tmux_snapshot:source_call/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":544,"end":559,"target":"t:erlang:non_neg_integer/0"},{"start":625,"end":646,"target":"t:tmux_server:hydration/0"},{"start":816,"end":830,"target":"t:tmux_snapshot:query_metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":846,"end":850,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":856,"end":860,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture identity and provenance. id identifies this snapshot, origin its registered endpoint and generation the endpoint lifetime. model_version names the row representation. graph describes relationship coverage, not atomicity.","body":"Live captures include endpoint, observed server_instance, tmux_version,\nmonotonic capture bounds in time_unit, source_calls, observed stdout bytes and\ncapabilities. Those fields can be absent in internally constructed partial\ncaptures. Query captures also include `t:query_metadata/0`. Opaque references\nand process identities are local values, not portable wire identifiers.\nhydration records the requested `t:tmux_server:hydration/0` strategy; source_calls\nshows which commands actually ran, including any schema-driven fallback."},"source":{"line":77,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-metadata-0"},{"id":"t:tmux_snapshot:query_metadata/0","publicId":"t:tmux_snapshot:query_metadata/0","qualifiedName":"tmux_snapshot:query_metadata/0","name":"query_metadata/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type query_metadata() ::\n          #{candidate_count := non_neg_integer(),\n            pushed_down := boolean(),\n            attempt := 1 | 2,\n            consistency := observed}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":57,"end":72,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":103,"end":110,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-query capture diagnostics. candidate_count is the deduplicated candidate identity count before local residuals and limits. pushed_down records a nontrivial native condition in the plan, not proof that its command ran: empty collections can skip it. source_calls records actual capture commands. The flag does not mean the full predicate was translated. attempt starts at one and increases only for an explicitly requested retry."},"source":{"line":62,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-query_metadata-0"},{"id":"t:tmux_snapshot:requirement/0","publicId":"t:tmux_snapshot:requirement/0","qualifiedName":"tmux_snapshot:requirement/0","name":"requirement/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type requirement() ::\n          {collection, tmux_schema:entity()} |\n          {field | relation, tmux_schema:entity(), atom()}.","params":[],"references":[{"start":46,"end":64,"target":"t:tmux_schema:entity/0"},{"start":99,"end":117,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":121,"end":125,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A collection, field or complete relationship needed for faithful local evaluation."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-requirement-0"},{"id":"t:tmux_snapshot:source_call/0","publicId":"t:tmux_snapshot:source_call/0","qualifiedName":"tmux_snapshot:source_call/0","name":"source_call/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_call() ::\n          #{command := binary(),\n            args := [binary()],\n            started := integer(),\n            finished := integer(),\n            stdout_bytes := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":77,"end":83,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":111,"end":118,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":146,"end":153,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":185,"end":200,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One completed capture command and its stdout byte count. started and finished are local monotonic microseconds, not wall-clock timestamps. The interval includes identity preflight and command completion; it is not an atomic read."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-source_call-0"},{"id":"t:tmux_snapshot:t/0","publicId":"t:tmux_snapshot:t/0","qualifiedName":"tmux_snapshot:t/0","name":"t/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An immutable captured graph with identity, indexes, coverage and source intervals."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_snapshot-t-0"},{"id":"tmux_version","publicId":"tmux_version","qualifiedName":"tmux_version","name":"tmux_version","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Parse the output of tmux -V without invoking tmux.","body":"Support covers tmux 3.3a through 3.8, including intermediate releases. The\nminimum-version check includes the patch letter; numeric feature comparisons\nuse major/minor components. CI tests the endpoints of the supported range. Use\n`tmux_server:version/1` for the daemon version observed by an endpoint."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_version"},{"id":"tmux_version:at_least/2","publicId":"tmux_version:at_least/2","qualifiedName":"tmux_version:at_least/2","name":"at_least/2","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"at_least/2\n-spec at_least(t(),\n               {non_neg_integer(), non_neg_integer()}) ->\n                  boolean().","references":[{"start":26,"end":27,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":47,"end":62,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":107,"end":114,"target":"t:erlang:boolean/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_version:t/0"}]},{"name":"Argument2","type":"{non_neg_integer(), non_neg_integer()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":1,"end":16,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":20,"end":35,"target":"t:erlang:non_neg_integer/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Compare numeric major/minor components with a required floor. Patch letters do not promote an older minor release. Performs no I/O."},"source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_version-at_least-2"},{"id":"tmux_version:parse/1","publicId":"tmux_version:parse/1","qualifiedName":"tmux_version:parse/1","name":"parse/1","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"parse/1\n-spec parse(binary()) ->\n               {ok, t()} |\n               {error, {invalid_tmux_version, term()}}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":20,"end":26,"target":"t:erlang:binary/0"},{"start":53,"end":54,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":106,"end":110,"target":"t:erlang:term/0"}],"params":[{"name":"Raw","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} |\n          {error, {invalid_tmux_version, term()}}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":53,"end":57,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Parse bounded tmux -V output into numeric components and patch/tracking metadata. This is pure parsing, not a probe or compatibility qualification."},"source":{"line":25,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_version-parse-1"},{"id":"tmux_version:require/1","publicId":"tmux_version:require/1","qualifiedName":"tmux_version:require/1","name":"require/1","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"require(Raw)\n-spec require(binary()) ->\n                 {ok, t()} |\n                 {error,\n                  {invalid_tmux_version |\n                   unsupported_tmux_version,\n                   term()}}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"start":62,"end":63,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":200,"end":204,"target":"t:erlang:term/0"}],"params":[{"name":"Raw","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} |\n          {error,\n           {invalid_tmux_version | unsupported_tmux_version,\n            term()}}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":103,"end":107,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Reject a tmux release below the supported floor.","examples":[{"lang":"erlang","code":"1> {ok, Version} = tmux_version:require(<<\"tmux 3.3a\">>), ok.\nok\n2> tmux_version:at_least(Version, {3, 4}).\nfalse"}]},"source":{"line":58,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_version-require-1"},{"id":"t:tmux_version:t/0","publicId":"t:tmux_version:t/0","qualifiedName":"tmux_version:t/0","name":"t/0","namespace":"tmux_version","parent":"tmux_version","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type t() ::\n          #{major := non_neg_integer(),\n            minor := non_neg_integer(),\n            patch := binary(),\n            tracking := boolean(),\n            raw := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":34,"end":49,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":74,"end":89,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":114,"end":120,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":148,"end":155,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":178,"end":184,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Parsed numeric daemon version plus patch, tracking and original-output metadata."},"source":{"line":17,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_version-t-0"},{"id":"tmux_window","publicId":"tmux_window","qualifiedName":"tmux_window","name":"tmux_window","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create physical windows in a session and act through their registered IDs.","body":"`create/2` accepts name, cwd, env, launch and detach, using the\nsession's next available index. It defaults to detached. `get/2`\nreads current fields; `rename/2` returns the command result and\nleaves previous records unchanged. Launch and environment options follow\n`tmux_session:create/2`. An empty shell command does not portably keep the\nwindow alive: older tmux releases execute it as a shell command. Use a running\nprogram when needed. Creation returns a fresh observed row or an error\nretaining a completed mutation and its result if the follow-up observation\nfails.\n\n`kill/1` destroys the physical window and all its links. Use\n`tmux_window_link:unlink/2` to remove one session membership. These calls\nperform I/O after validating their inputs. `select_layout/2`\nchanges the physical window's layout across all its session links; previously\nobserved pane geometry remains unchanged in captured values."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window"},{"id":"tmux_window:create/2","publicId":"tmux_window:create/2","qualifiedName":"tmux_window:create/2","name":"create/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"create(Session, Options)\n-spec create(tmux_model:session(), create_options()) ->\n                {ok, tmux_model:window()} | {error, map()}.","references":[{"start":38,"end":56,"target":"t:tmux_model:session/0"},{"start":60,"end":74,"target":"t:tmux_window:create_options/0"},{"start":102,"end":119,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":133,"end":136,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"create_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_window:create_options/0"}]}],"returns":"{ok, tmux_model:window()} | {error, map()}","returnsReferences":[{"start":5,"end":22,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Create a physical window in the session's next free index and observe it. Defaults to detached. Launch, cwd and environment follow `tmux_session:create/2`. Performs I/O and retains completed-mutation details if observation fails."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-create-2"},{"id":"tmux_window:get/2","publicId":"tmux_window:get/2","qualifiedName":"tmux_window:get/2","name":"get/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:window_id()) ->\n             {ok, tmux_model:window()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":63,"target":"t:tmux_model:window_id/0"},{"start":88,"end":105,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":119,"end":122,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:window_id()","typeReferences":[{"start":0,"end":20,"target":"t:tmux_model:window_id/0"}]}],"returns":"{ok, tmux_model:window()} | {error, map()}","returnsReferences":[{"start":5,"end":22,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicitly read a physical window by stable ID. Returns a fresh record or target_gone. Physical windows do not have a universal session or window index."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-get-2"},{"id":"tmux_window:kill/1","publicId":"tmux_window:kill/1","qualifiedName":"tmux_window:kill/1","name":"kill/1","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Window)\n-spec kill(tmux_model:window()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":24,"end":41,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":67,"end":70,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":84,"end":87,"target":"t:erlang:map/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy the physical window and all of its session links. This does not unlink only one membership. Performs I/O after origin and target validation."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-kill-1"},{"id":"tmux_window:rename/2","publicId":"tmux_window:rename/2","qualifiedName":"tmux_window:rename/2","name":"rename/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Window, Name)\n-spec rename(tmux_model:window(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":34,"end":51,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":106,"end":109,"target":"t:erlang:map/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename the registered physical window with a literal name. Performs I/O and returns the command result. Captured rows and snapshots remain unchanged."},"source":{"line":63,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-rename-2"},{"id":"tmux_window:respawn/2","publicId":"tmux_window:respawn/2","qualifiedName":"tmux_window:respawn/2","name":"respawn/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"respawn(Window, Options)\n-spec respawn(tmux_model:window(), respawn_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":39,"end":56,"target":"t:tmux_model:window/0"},{"start":60,"end":75,"target":"t:tmux_window:respawn_options/0"},{"start":104,"end":128,"target":"t:tmux_operation:completed/0"},{"start":159,"end":181,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Options","type":"respawn_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_window:respawn_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn a registered physical window across all its session links. tmux keeps the first pane's ID, removes the other panes and rebuilds a single-pane layout. force defaults false: a window with a running pane normally returns command_error. force = true permits closing existing PTYs. Command completion does not establish former-job termination or application readiness. Other panes can already be removed if a later spawn step fails. Respawn also selects this window in tmux's resolved session. For a window linked into several sessions, tmux chooses that context from the physical ID; this facade does not pin selection or environment to a captured membership.","body":"launch defaults to previous and reuses the retained pane's saved command.\nExplicit argv and shell maps, saved cwd and fresh-spawn environment rules\nfollow `tmux_pane:respawn/2`, using the resolved session's environment. This\nphysical-window mutation affects every link. Performs I/O after validation and\nreturns the command result without refreshing rows. Use `get/2` or a new\nsnapshot for current data."},"source":{"line":96,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-respawn-2"},{"id":"tmux_window:select_layout/2","publicId":"tmux_window:select_layout/2","qualifiedName":"tmux_window:select_layout/2","name":"select_layout/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"select_layout(Window, Layout)\n-spec select_layout(tmux_model:window(), layout()) ->\n                       {ok, tmux_operation:completed()} |\n                       {error, tmux_operation:failure()}.","references":[{"start":50,"end":67,"target":"t:tmux_model:window/0"},{"start":71,"end":77,"target":"t:tmux_window:layout/0"},{"start":112,"end":136,"target":"t:tmux_operation:completed/0"},{"start":173,"end":195,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Layout","type":"layout()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_window:layout/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select a built-in arrangement or restore a literal serialized layout for this registered physical window. Binary names must exactly match one of the five built-ins; abbreviations and other names are rejected. Legacy serialized layouts need four hexadecimal checksum digits, a comma and nonempty data. This guard avoids a malformed-header crash in tmux 3.3 and 3.3a.","body":"Native JSON v2 layouts require a bounded JSON object with V = 2 and an L\nobject. They return unsupported_capability on tmux before 3.8 without\ndispatching a tmux command. This preserves `get/2` layout restoration on newer\nservers.\n\nExecution unzooms the window and changes it in every linked session. tmux\nvalidates serialized geometry; malformed geometry can return a command error.\nThe layout argument uses no shell or format expansion. Existing rows are not\nrefreshed; use `get/2` or a fresh snapshot to observe layout and pane\ngeometry.\n\nUnsupported atom names fail before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_window:select_layout(invalid_row, unknown_layout).\n{error,#{code => invalid_layout,path => [layout]}}"}]},"source":{"line":131,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window-select_layout-2"},{"id":"t:tmux_window:create_options/0","publicId":"t:tmux_window:create_options/0","qualifiedName":"tmux_window:create_options/0","name":"create_options/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type create_options() ::\n          #{name => binary(),\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":106,"end":112,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":118,"end":124,"target":"t:erlang:binary/0"},{"start":151,"end":175,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":201,"end":208,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Physical-window creation options; defaults to a detached window at the next free session index."},"source":{"line":25,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window-create_options-0"},{"id":"t:tmux_window:layout/0","publicId":"t:tmux_window:layout/0","qualifiedName":"tmux_window:layout/0","name":"layout/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type layout() ::\n          even_horizontal | even_vertical |\n          main_horizontal | main_vertical | tiled |\n          binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":124,"end":130,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A built-in arrangement, its exact binary name, or a serialized layout. Native JSON v2 requires tmux 3.8."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window-layout-0"},{"id":"t:tmux_window:respawn_options/0","publicId":"t:tmux_window:respawn_options/0","qualifiedName":"tmux_window:respawn_options/0","name":"respawn_options/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_options() ::\n          #{force => boolean(),\n            launch => tmux_command:respawn_spec(),\n            cwd => binary(),\n            env => #{binary() => binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"start":81,"end":106,"target":"t:tmux_command:respawn_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":129,"end":135,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":172,"end":178,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Physical-window respawn options. Defaults: force false, launch previous, saved cwd. A forced respawn removes other panes."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window-respawn_options-0"},{"id":"tmux_window_link","publicId":"tmux_window_link","qualifiedName":"tmux_window_link","name":"tmux_window_link","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Act on a physical window's observed membership in a particular session.","body":"A window link is identified by session ID, window index and expected physical\nwindow ID. It has no stable tmux link ID. These calls check that the observed\nmembership still names the expected window before dispatching an action.\nMissing or replaced membership returns stale_link. A link that moves away and\nback to the same coordinates and physical window cannot be distinguished.\n\nThe preflight and action use separate one-shot commands. Concurrent changes\nafter preflight can still affect the action; this is not atomic\ncompare-and-act. All input rows must belong to the same registered owner.\nRe-read or explicitly bind rows when using another owner. Closed owners and\nknown restarts invalidate their rows. Every call performs explicit I/O after\nvalidating its arguments.\n\nUse `tmux_window:kill/1` to destroy a physical window across all memberships.\nUse `unlink/2` to remove one membership. Existing rows and\nsnapshots are never refreshed by actions; use `get/3` or a\nnew snapshot for current memberships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link"},{"id":"tmux_window_link:get/3","publicId":"tmux_window_link:get/3","qualifiedName":"tmux_window_link:get/3","name":"get/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, SessionId, Index)\n-spec get(tmux_server:t(),\n          tmux_model:session_id(),\n          index()) ->\n             {ok, tmux_model:window_link()} |\n             {error, map()}.","references":[{"start":40,"end":53,"target":"t:tmux_server:t/0"},{"start":67,"end":88,"target":"t:tmux_model:session_id/0"},{"start":102,"end":107,"target":"t:tmux_window_link:index/0"},{"start":132,"end":154,"target":"t:tmux_model:window_link/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":181,"end":184,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"SessionId","type":"tmux_model:session_id()","typeReferences":[{"start":0,"end":21,"target":"t:tmux_model:session_id/0"}]},{"name":"Index","type":"index()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_window_link:index/0"}]}],"returns":"{ok, tmux_model:window_link()} | {error, map()}","returnsReferences":[{"start":5,"end":27,"target":"t:tmux_model:window_link/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":41,"end":44,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a current membership at the explicit session ID and index. The returned native row carries its registered owner and a new observation identity. Returns target_gone if the session or index is absent. This read does not make later actions atomic and does not refresh previously captured links.","body":"Invalid indexes are rejected before I/O:","examples":[{"lang":"erlang","code":"1> tmux_window_link:get(invalid_server, <<\"$0\">>, -1).\n{error,#{code => invalid_option,path => [index]}}"}]},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-get-3"},{"id":"tmux_window_link:link/3","publicId":"tmux_window_link:link/3","qualifiedName":"tmux_window_link:link/3","name":"link/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"link(Link, Session, Options)\n-spec link(tmux_model:window_link(),\n           tmux_model:session(),\n           placement_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":40,"end":62,"target":"t:tmux_model:window_link/0"},{"start":77,"end":95,"target":"t:tmux_model:session/0"},{"start":110,"end":127,"target":"t:tmux_window_link:placement_options/0"},{"start":153,"end":177,"target":"t:tmux_operation:completed/0"},{"start":205,"end":227,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"placement_options()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_window_link:placement_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Add another membership of this link's physical window to the destination session and explicit index. Defaults to detached and refuses an occupied index. replace = true maps to tmux -k and can destroy the occupied window. Returns the command result; use `get/3` to observe the new membership. The source membership remains. Session groups and renumber-windows retain their tmux semantics. Performs I/O after owner and membership checks."},"source":{"line":87,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-link-3"},{"id":"tmux_window_link:move/3","publicId":"tmux_window_link:move/3","qualifiedName":"tmux_window_link:move/3","name":"move/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"move(Link, Session, Options)\n-spec move(tmux_model:window_link(),\n           tmux_model:session(),\n           placement_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":40,"end":62,"target":"t:tmux_model:window_link/0"},{"start":77,"end":95,"target":"t:tmux_model:session/0"},{"start":110,"end":127,"target":"t:tmux_window_link:placement_options/0"},{"start":153,"end":177,"target":"t:tmux_operation:completed/0"},{"start":205,"end":227,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"placement_options()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_window_link:placement_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Move this membership to the destination session and explicit index, leaving its physical window's other links intact. Placement options follow `link/3`. Moving the final window out of a session can destroy that session; automatic renumbering and session groups can change other memberships. Captured rows remain unchanged. Returns the command result after observed preflight."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-move-3"},{"id":"tmux_window_link:select/1","publicId":"tmux_window_link:select/1","qualifiedName":"tmux_window_link:select/1","name":"select/1","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"select(Link)\n-spec select(tmux_model:window_link()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":26,"end":48,"target":"t:tmux_model:window_link/0"},{"start":76,"end":100,"target":"t:tmux_operation:completed/0"},{"start":130,"end":152,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select this membership as its session's current window after checking the expected physical window. Performs I/O and returns the command result."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-select-1"},{"id":"tmux_window_link:swap/3","publicId":"tmux_window_link:swap/3","qualifiedName":"tmux_window_link:swap/3","name":"swap/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"swap(Source, Destination, Options)\n-spec swap(tmux_model:window_link(),\n           tmux_model:window_link(),\n           swap_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":46,"end":68,"target":"t:tmux_model:window_link/0"},{"start":83,"end":105,"target":"t:tmux_model:window_link/0"},{"start":120,"end":132,"target":"t:tmux_window_link:swap_options/0"},{"start":158,"end":182,"target":"t:tmux_operation:completed/0"},{"start":210,"end":232,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Source","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Destination","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Options","type":"swap_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_window_link:swap_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Swap the physical windows at two checked memberships. Other links to either window remain intact. detach maps to tmux -d and defaults true. tmux applies its session-selection and group-synchronization rules. Returns the command result; old rows still name their original expected windows and can become stale. Performs I/O, with the documented gap between preflight and action."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-swap-3"},{"id":"tmux_window_link:unlink/2","publicId":"tmux_window_link:unlink/2","qualifiedName":"tmux_window_link:unlink/2","name":"unlink/2","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"unlink(Link, Options)\n-spec unlink(tmux_model:window_link(), unlink_options()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":35,"end":57,"target":"t:tmux_model:window_link/0"},{"start":61,"end":75,"target":"t:tmux_window_link:unlink_options/0"},{"start":103,"end":127,"target":"t:tmux_operation:completed/0"},{"start":157,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Options","type":"unlink_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_window_link:unlink_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one checked membership. force defaults false, retaining tmux's protection for windows linked to only one session. force = true permits removing the last link, destroying that physical window and possibly its session. Duplicate links within one session retain tmux's native protection rules. Performs I/O and returns the command result without refreshing rows."},"source":{"line":128,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"tmux_window_link-unlink-2"},{"id":"t:tmux_window_link:index/0","publicId":"t:tmux_window_link:index/0","qualifiedName":"tmux_window_link:index/0","name":"index/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type index() :: 0..2147483647.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An explicit tmux window index; relative and next-free selectors are not accepted."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window_link-index-0"},{"id":"t:tmux_window_link:placement_options/0","publicId":"t:tmux_window_link:placement_options/0","qualifiedName":"tmux_window_link:placement_options/0","name":"placement_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type placement_options() ::\n          #{index := index(),\n            detach => boolean(),\n            replace => boolean()}.","params":[],"references":[{"start":50,"end":55,"target":"t:tmux_window_link:index/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":81,"end":88,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":115,"end":122,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destination index is required. Defaults: detach true, replace false. Replacement may destroy the destination window."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window_link-placement_options-0"},{"id":"t:tmux_window_link:swap_options/0","publicId":"t:tmux_window_link:swap_options/0","qualifiedName":"tmux_window_link:swap_options/0","name":"swap_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type swap_options() :: #{detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":36,"end":43,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Maps detach to tmux's -d flag, default true."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window_link-swap_options-0"},{"id":"t:tmux_window_link:unlink_options/0","publicId":"t:tmux_window_link:unlink_options/0","qualifiedName":"tmux_window_link:unlink_options/0","name":"unlink_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type unlink_options() :: #{force => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":37,"end":44,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Force defaults false. Force permits unlinking the last membership and destroying its physical window."},"source":{"line":33,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","extractedRevision":"f1a2e66c0fa15d1e8d4efa2725a159121815293b"},"slug":"t-tmux_window_link-unlink_options-0"}]}
+{"port":"erlang","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractor":"@libtmux/api-model@0.0.1 (Erlang EEP-48 and abstract code v3)","nativeProvenance":{"files":[{"path":".tool-versions","sha256":"73a9c039345d63a5316d1818639cabf8f563af4752b3d25168aff80beae90a68"},{"path":"apps/libtmux_erlang/rebar.config","sha256":"7dde37bc878d42712eb562a96f7b2bef0f717d552c1fe115c3224cf7a39c59a2"},{"path":"apps/libtmux_erlang/src/libtmux_erlang.app.src","sha256":"c0dabd09a69c341798a2f66fe042d3e810a53b2a858fa4781c1273936c16b2db"},{"path":"apps/libtmux_erlang/src/libtmux_erlang_app.erl","sha256":"b649483a5e0bf6cc3a377aa06a381e6afe2b316f0c64590d13dc650520040328"},{"path":"apps/libtmux_erlang/src/tmux_admission.erl","sha256":"78330dddda6ae5854d2e72585523c6664293167d4b25273015494f8877029b4f"},{"path":"apps/libtmux_erlang/src/tmux_args.erl","sha256":"f054894dfd02179f09fe153afacf29dd9e8494ec381abd07ab92b56300ca10cd"},{"path":"apps/libtmux_erlang/src/tmux_buffer.erl","sha256":"c05edba9f3cfde487d699b5ed7e83b8353f0d7419db309a22d8a0f938572f996"},{"path":"apps/libtmux_erlang/src/tmux_buffer_codec.erl","sha256":"872d28160204881f0b11de18ae99704ca17a1e5914819abd3c1c30298427121e"},{"path":"apps/libtmux_erlang/src/tmux_capability.erl","sha256":"1514ac1583f5f870c067585f4509a1304147b2e4527a7026dfdac367c54c72c1"},{"path":"apps/libtmux_erlang/src/tmux_capability_data.erl","sha256":"e5a6f66ded73cb16e53d9f6bbbc0d6066088e58598b8e970b37e6bb3ea142e1e"},{"path":"apps/libtmux_erlang/src/tmux_command.erl","sha256":"4ef3e833cd4beeb62f8dc34994fd4071a0df675c3e2304b3e80fcd6d9579153c"},{"path":"apps/libtmux_erlang/src/tmux_control.erl","sha256":"0a5412aa42a2616a12a07310facd5bd2a669e2753949c3dc4966fac7aaeb0bdf"},{"path":"apps/libtmux_erlang/src/tmux_control_codec.erl","sha256":"a3395198fe0ebba49dc598f0e2503a14f2b00b2ccb36982c90513f851a6a5b48"},{"path":"apps/libtmux_erlang/src/tmux_error.erl","sha256":"ccb10f5a434672a20068759ee1b54ba6c6c503f0f876247aad7125c6b4c5ad82"},{"path":"apps/libtmux_erlang/src/tmux_filter.erl","sha256":"b582961447a700c38d348230a016918cf07cec169ab46d11b4c9a925857a142b"},{"path":"apps/libtmux_erlang/src/tmux_filter_eval.erl","sha256":"5e715cfa4110951771cbd7fe13eb2797a2ff2dd2d38ed5838b500524a3f7fbc2"},{"path":"apps/libtmux_erlang/src/tmux_hook.erl","sha256":"723c166ff42524679066011916463761ad5d4e9ccc6e9c901beb3cca6df53a3d"},{"path":"apps/libtmux_erlang/src/tmux_identity.erl","sha256":"31ab809d3c407e0214f6b952e4e24cc5289f3d4ee305f6fe0b9b1520f4af9d7d"},{"path":"apps/libtmux_erlang/src/tmux_json.erl","sha256":"2dce31dd87dae4e32c314de5c1ddefcee077cfef09a78cbcf6f660748573ddfc"},{"path":"apps/libtmux_erlang/src/tmux_key.erl","sha256":"00c7d3a141d377c115cf2a6d010312aa4c006d34355111ff51424b3c2b2a3e23"},{"path":"apps/libtmux_erlang/src/tmux_log.erl","sha256":"885dcb198a82a0ed13f8c766e63e3953e4e9134f5d4bd2f86e79f0e0de65783a"},{"path":"apps/libtmux_erlang/src/tmux_matcher.erl","sha256":"b599f732e73ad9c7701df6c9c65c9524645c988bb5ba2d0729b9004136d29c16"},{"path":"apps/libtmux_erlang/src/tmux_model.erl","sha256":"519cfeb36fa0ea3df6d742edc87ded1f9d4800fc4fe7c662f2e676e29a4ce0a9"},{"path":"apps/libtmux_erlang/src/tmux_observe.erl","sha256":"4e726b823568a66cdf0f3c34aeb6c0b55651522da9a6263d077a2926cd699da0"},{"path":"apps/libtmux_erlang/src/tmux_operation.erl","sha256":"f5d34e31af1ac17e267bff6529a454d095ff3c7c238d64d6bbb0002e54285c47"},{"path":"apps/libtmux_erlang/src/tmux_option.erl","sha256":"c1872d0d9f74f136d0fbb1a2b28232d4245a197f8fd84d78ae6bf4200fd0088a"},{"path":"apps/libtmux_erlang/src/tmux_option_batch.erl","sha256":"16b90a2b4e8bf168dd3d5bd56bfbb4a561cfd9ff8f43054917ce9500488b195b"},{"path":"apps/libtmux_erlang/src/tmux_option_codec.erl","sha256":"cd3dc1cc2d457cd711247c539f0fc0e3498303180751724ebae77462cede9b6d"},{"path":"apps/libtmux_erlang/src/tmux_option_data.erl","sha256":"8fe72d14d2ec8d6a9aef7ac8a46923f3c70f47f45b5c6fcd0b1754eae8ca0ae4"},{"path":"apps/libtmux_erlang/src/tmux_option_scope.erl","sha256":"7f6227cd1808bf8b27df12fafc3c35c073797efee7a4ed9f89e19bc2b498ed11"},{"path":"apps/libtmux_erlang/src/tmux_owned_server.erl","sha256":"17521c819d7aea427429dc18aafee101544a6f85c0772857d540d1dd887a44f3"},{"path":"apps/libtmux_erlang/src/tmux_pane.erl","sha256":"e71ac56dab19886495cae801a1a83d85123e519de1c10ba8eb4128c8ff33db48"},{"path":"apps/libtmux_erlang/src/tmux_query.erl","sha256":"687cc6d89f68815662d8154ed3326ed69dd5b665c4cc1fec10036022c52cb641"},{"path":"apps/libtmux_erlang/src/tmux_query_plan.erl","sha256":"98299c186428ccc70588cee87b65e89d172045b89d01d0c88996834454238a93"},{"path":"apps/libtmux_erlang/src/tmux_regex.erl","sha256":"c97133a505dfbf7a54b0b59645429a3a512482bec99dfc5cc8da0ef27664af44"},{"path":"apps/libtmux_erlang/src/tmux_registry.erl","sha256":"e0370601b396566bb24323a65e0fc2e6a1930c6298cbd125590009a4855d0740"},{"path":"apps/libtmux_erlang/src/tmux_schema.erl","sha256":"85ebfc0c7f53cf4e7952f9ec440395646d48d9100ad2ea191d9c053759625a65"},{"path":"apps/libtmux_erlang/src/tmux_schema_data.erl","sha256":"4cd255118e2b207d40507fa2a5b91af7555e41134986eff7c58ce2349a96560d"},{"path":"apps/libtmux_erlang/src/tmux_scope.erl","sha256":"02c1624a9618fb24022b13263e6de0ca14ca60e5ff7b773e1ecfdd742b2ea03b"},{"path":"apps/libtmux_erlang/src/tmux_select.erl","sha256":"49f16937a1edf0057364f54718907d48fa2442a6410c38218f984c456874968c"},{"path":"apps/libtmux_erlang/src/tmux_server.erl","sha256":"e54e0940fb9c86985620e0c983538fbcf9e4e06b0c36b925dc7c46c21451d516"},{"path":"apps/libtmux_erlang/src/tmux_session.erl","sha256":"150217b8d739092eded788198c86e0d82d6e7e81453ab8c3423c53ea8d4280d0"},{"path":"apps/libtmux_erlang/src/tmux_snapshot.erl","sha256":"570e30612017e0a80be44fcae0ad5aaf44968588244916efc93516751dc58f81"},{"path":"apps/libtmux_erlang/src/tmux_sup.erl","sha256":"d0769251b68e8118e8cb58d2cd974cbf59e8c72b5713e738d6b82df14cd400ee"},{"path":"apps/libtmux_erlang/src/tmux_target.erl","sha256":"107de5ba111b6ff3641c3e1ba2197b6a66808a654e031b0837ff2befaad67d5d"},{"path":"apps/libtmux_erlang/src/tmux_text_codec.erl","sha256":"22b3823103dd84df3e21d6b9e2362da9f74c062731253fbac0b555868be758db"},{"path":"apps/libtmux_erlang/src/tmux_transport.erl","sha256":"1be3ba6148a39b041720b1123f42fd1d9142993dff39e8b655b24db245f25b82"},{"path":"apps/libtmux_erlang/src/tmux_transport_codec.erl","sha256":"516f5d3d79f31702a7b27b09945e1f5b8b9cfce613ede4ac9edc817f941686df"},{"path":"apps/libtmux_erlang/src/tmux_version.erl","sha256":"c09c120c90ec42a7cc55772b13823e3169259c68f2330537f1e5cb19e087d283"},{"path":"apps/libtmux_erlang/src/tmux_window.erl","sha256":"8fd8325549b1756f76c3fceb36ccfcf15068ec9c0cfa6a290da8ae3067817a4e"},{"path":"apps/libtmux_erlang/src/tmux_window_link.erl","sha256":"3584235656fc15976074e964f5ab2042e7dc83ed0fa3748a28059da32dd7550c"},{"path":"apps/libtmux_erlang/test/tmux_admission_tests.erl","sha256":"90cd16fd73aaaa9ac32ac1ac2b6ccf16d879b5dee88950d42d44455ac33c92a3"},{"path":"apps/libtmux_erlang/test/tmux_buffer_tests.erl","sha256":"0f117487e30b8edc908393ed85f3837d92c3f4309b0f5e7233c3926822bc8fee"},{"path":"apps/libtmux_erlang/test/tmux_capability_tests.erl","sha256":"7062a4401ae2f6d42389780c200957d85613eb635721c294bd8916d851f4bbec"},{"path":"apps/libtmux_erlang/test/tmux_command_tests.erl","sha256":"d0c8e817342d2d2000a097ef248557f3f22c02b149ac068d6da6faf2719f8dfe"},{"path":"apps/libtmux_erlang/test/tmux_domain_tests.erl","sha256":"8df9b7ab8fcf08838cb83bf814e610a8d2fe042abb8c5a7861700d5243b8cc9f"},{"path":"apps/libtmux_erlang/test/tmux_error_tests.erl","sha256":"9561f706fe80150aac64481762a7be1ecd28f26d7b643cf194774691a1eda6e2"},{"path":"apps/libtmux_erlang/test/tmux_filter_fixture_tests.erl","sha256":"2042d790c9a8db07d0260aeb18a1658f1715299a7493d80c95f9ab6667f60f9c"},{"path":"apps/libtmux_erlang/test/tmux_filter_tests.erl","sha256":"297207998c206b10f71799cb9b642fb435b397e8e076f9c5780f5bae4bc2d82e"},{"path":"apps/libtmux_erlang/test/tmux_hook_tests.erl","sha256":"4f9bbdc801ab3d6e14609be8c0f2477bc00d530d9c829b719a8c98a7e3160482"},{"path":"apps/libtmux_erlang/test/tmux_identity_tests.erl","sha256":"fcf254ed09fc1111b65eb4a5dab2304ee013d8eae937cf590b496c3955453945"},{"path":"apps/libtmux_erlang/test/tmux_json_tests.erl","sha256":"55d60e58bd058a1882c1288880cca60596397702594791a7f4907f6bccdd6408"},{"path":"apps/libtmux_erlang/test/tmux_key_tests.erl","sha256":"d39af985776d7ed68e4b39f535b0513f2cda3b95d27ee7f438c64d7490e5f8f8"},{"path":"apps/libtmux_erlang/test/tmux_model_tests.erl","sha256":"ed7b34128ff3c55020a8b430814cd21d7fbd0af49d645d1caf640c9b12a1bde5"},{"path":"apps/libtmux_erlang/test/tmux_option_tests.erl","sha256":"35a8b9a53fe2545095255c04ef0e5d92e21ff09405e6204a73b5bbbbdb25bc07"},{"path":"apps/libtmux_erlang/test/tmux_query_tests.erl","sha256":"3f6a7b2d3dfbcb252b62e2559e2318c976541b763e507ddbf57133582e121cb9"},{"path":"apps/libtmux_erlang/test/tmux_regex_tests.erl","sha256":"53f60668b1c3cf9449ab59b5576e5d367902f374aa6d5a99e50dfa5d0c96a05c"},{"path":"apps/libtmux_erlang/test/tmux_registry_tests.erl","sha256":"1564e63d63be02e2ddc13e58a67a003eb77e3129b4f6d6585d6cb2ef26d8fbc4"},{"path":"apps/libtmux_erlang/test/tmux_scope_tests.erl","sha256":"575a142cc074ffcd51784bfba68bd81b8ab1fb53684e2c47fa912cbf9ae38f19"},{"path":"apps/libtmux_erlang/test/tmux_select_tests.erl","sha256":"130475107a7ade6e18b98987ae222ff4ea12ee9bdb40cf90fd40d37b13292f74"},{"path":"apps/libtmux_erlang/test/tmux_snapshot_tests.erl","sha256":"641dd3e523efdd7a313d5bc8109d13419bedc50f1565a2abbdb4226594a51f60"},{"path":"apps/libtmux_erlang/test/tmux_text_codec_tests.erl","sha256":"fd089f5e50f509390051325c009eeb9abc3aca4a5c046c3562d64061f2c77bd0"},{"path":"apps/libtmux_erlang/test/tmux_transport_codec_tests.erl","sha256":"8769931bdc39f25e927ead06b17b985d192be54610b799ced428d4fab5d351cf"},{"path":"apps/libtmux_erlang/test/tmux_version_tests.erl","sha256":"3867637a0194ef1eee541ad311d3b296436c0220e2323b504b17243a8a588bd1"},{"path":"examples/buffer_demo.erl","sha256":"d4579d644f0d68f5b864036351ad538c7b18f73469d33fa933da248b72028f50"},{"path":"examples/command_demo.erl","sha256":"c9af9f446d73710ade39ee59a29494a9df5be076172a7efa977bc35034a33622"},{"path":"examples/config_demo.erl","sha256":"0d861a00b4f1025976a1c10e1e4873d08cedcf5f622d1d307420672f4caca3e4"},{"path":"examples/control_demo.erl","sha256":"3e407160772d5677ffb6983405bcf032d728e65e3c6eec9566445c41b2a49d7b"},{"path":"examples/filter_demo.erl","sha256":"9b3467b20497d568c0832685c790fcd0909133a15d5814282ccf55765771d321"},{"path":"examples/hook_demo.erl","sha256":"5c6c777bc6a2ab716a00bef55f44b4cf7fe43ad29ad31b55ea092acdeef49087"},{"path":"examples/inspect_demo.erl","sha256":"a87e20080863153c687682f7c21961dd50edd853254dac38f8c09a1b34f03bbd"},{"path":"examples/job_demo.erl","sha256":"8ddbd70130f47ae022d2224646b132e18aa5178b50aa6965b33612230ddf3bf5"},{"path":"examples/key_demo.erl","sha256":"572bb44ae0bca5354d9080993d6010d97caa25dcaaad89417912f4ddcca975e4"},{"path":"examples/linked_graph.erl","sha256":"d6d5f7b51e76e2023c6f33a1547ff71534f6107d705db20d2012122f552c6bf0"},{"path":"examples/native_consumer.erl","sha256":"fe3a5943ada5885c09918b3693510de612437ef6b8bd3b431674c846ae648eea"},{"path":"examples/options_demo.erl","sha256":"37a5a00ae52c25b5eef4ff079b6b5fe8155f54be85488d456ba1399dcddec468"},{"path":"examples/pane_demo.erl","sha256":"e103746aebc97ed5c939e384c935f2bf7830c0e0efa0c269fc70d5dec7b6f300"},{"path":"examples/pipe_demo.erl","sha256":"a5ea3562db13830139f6ffcf95b4b0ef0fb5dee7dcb408335aaad3ac80519e6d"},{"path":"examples/readme_demo.erl","sha256":"1ff24e66b6ac576c63eb2fc481aeeb17ab641608ec4ac56c09f9266e34fcf850"},{"path":"property/prop_tmux_filter.erl","sha256":"1a918ae522b6ae675c3ec2c42ffbb87bfd8cb30bb770ae9ac5f7bf6740b7713e"},{"path":"property/prop_tmux_graph.erl","sha256":"2fe1dfd9e870a5e98ce6a7e4c89a1a33b72d0661dc68860a6d6be83470e17fee"},{"path":"rebar.config","sha256":"faac9e9d16e8df896c8bb4bccb71214a6c6096e395301a97a38c0c89c9e56c74"},{"path":"rebar.lock","sha256":"11147eb50b093a61fe80253dae762d703387f23054d00907217c4ab3dc2d6b8c"},{"path":"test/consumers/model_types_bad.erl","sha256":"643fe7c662cc031de656149da55ec3c038541a7a1d3ece01ed7b2ca21bc5d68a"},{"path":"test/consumers/model_types_ok.erl","sha256":"fcababe54e4626a8827c319025bc801bcac51457489281d67b02a31edaebf763"},{"path":"test/tmux_buffer_SUITE.erl","sha256":"605251515daff77735e714ac9bd42abdb41695c650236aa3ee1d1d15e77ebbd0"},{"path":"test/tmux_channel_SUITE.erl","sha256":"0c72df0e5291895ee491fc9b6148100bd19c993546f932db35da4240d4f29a34"},{"path":"test/tmux_command_SUITE.erl","sha256":"7d8bc30cff9cb9168885be97a9929090d94314871d2cba6123a327dfe30c464e"},{"path":"test/tmux_control_SUITE.erl","sha256":"787e82c6ab419ceb69d7e75146b1750bf0d8425281b30e541f3865184e352a2f"},{"path":"test/tmux_control_codec_SUITE.erl","sha256":"3244294cd87b33384cadfb2e53ff501aecabb571388e99faf9cbc057158558ce"},{"path":"test/tmux_control_codec_tests.erl","sha256":"6730a09af09dbd5ebcd5e4cb8dd8abafc0c339d7cf14b8f79926a755b95c3705"},{"path":"test/tmux_diagnostics_SUITE.erl","sha256":"72aa812052d70b5af8b44777e0d39dca8f94f43faa3fd1c78c981157d4596246"},{"path":"test/tmux_docs_SUITE.erl","sha256":"fe2e757d2b3496eeb9928ab6fbea00434b5b9bd00bec199730162b14400cf589"},{"path":"test/tmux_domain_SUITE.erl","sha256":"53bf4ec2c1e4ebdbdb11f3cc3f4e235140cb3aa6e9859bc7a79c3ea4b7c30fa7"},{"path":"test/tmux_fixture_SUITE.erl","sha256":"2a7ad27ad63f1892f347fb3b272231a9ed3603f8025527931f6f98024b469e73"},{"path":"test/tmux_hook_SUITE.erl","sha256":"c020bd17251344e15d823e05e0a4ec8be4e05c6b6d3582af2aa659ff08577ef6"},{"path":"test/tmux_key_SUITE.erl","sha256":"3b5d0da672633a7470446008b79741900df9f88d5c12e21559445f2f1f1b2412"},{"path":"test/tmux_option_SUITE.erl","sha256":"88a323f26b52025092e31255f2ab944859cadd45e74ff7fd90cd6d76da0e6583"},{"path":"test/tmux_owned_server_SUITE.erl","sha256":"de43f1cfecf8c20f349a9fcaae0b02fd0559a7ab3f8621caf6f4a0cf40fa0980"},{"path":"test/tmux_pipe_SUITE.erl","sha256":"cfb3cdd298f43dc66afb306f6ac1f5f692968958a959fa8b7bbb2beaaa602b46"},{"path":"test/tmux_query_SUITE.erl","sha256":"63e71283c8aadd680c6fb006c7f9177c66b0c05b258b3849d20ea9e05699da06"},{"path":"test/tmux_server_SUITE.erl","sha256":"af9bdd800ddf33a37d4d48d5b4329f1f90dd8ba93797cfe4beb04e1587244de4"},{"path":"test/tmux_test_fixture.erl","sha256":"48b64d04a7fa2c0c4848f5203c76bc11daa98ddf3d5e1f7cc4ac5a3793ca8d00"},{"path":"test/tmux_topology_SUITE.erl","sha256":"3e5fd3cde6709593e169a93bc1ee684d3e460788400b514439009da3e58397bf"},{"path":"test/tmux_transport_SUITE.erl","sha256":"17ca53bf22a720e3b4b57ee9be9a9e8d2517abd3659b2c79c4b81d92a1eaf01c"}],"exporter":{"name":"Erlang EEP-48 and abstract code","version":3,"otp":"29.1.2","columns":60,"source_sha256":"2fc491ad480e74fded943bf072d5bfd452116a9dfc6dc7062860727fe487f1ab"}},"sources":[{"package":"libtmux_erlang","product":"core","version":"0.0.1","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"}],"symbols":[{"id":"tmux_buffer","publicId":"tmux_buffer","qualifiedName":"tmux_buffer","name":"tmux_buffer","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Load, inspect and paste tmux byte buffers through an explicit endpoint.","body":"Use `load/3` for binary payloads, including NUL bytes, and `show/2` to read\nthem back without terminal escaping or an added newline. `list/1` returns\ncaptured metadata in tmux's newest-first order; it never loads payloads.\n`paste/3` sends a named buffer to a registered pane. Direct input is available\nthrough `tmux_pane:send_text/2`.\n\nNames are NUL-free binaries, distinct from payload bytes. New names retain\ntmux's storage rules: 3.7+ cleans names and can reject control bytes or escape\nbackslashes. Use observed names from `list/1` for subsequent calls. Empty load\ninput is tmux's no-op; it neither creates nor clears a buffer. `delete/2`\nremoves a buffer explicitly. Names have no persistent object identity, and\nconcurrent commands can replace a buffer between calls.\n\nAll operations except `capabilities/1` perform explicit I/O. They use the\none-shot transport and preserve operational errors and ownership checks.\nThe [buffer guide](buffers.md) shows a complete byte round trip."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer"},{"id":"tmux_buffer:capabilities/1","publicId":"tmux_buffer:capabilities/1","qualifiedName":"tmux_buffer:capabilities/1","name":"capabilities/1","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"capabilities(Version)\n-spec capabilities(tmux_version:t()) -> capabilities().","references":[{"start":41,"end":55,"target":"t:tmux_version:t/0"},{"start":62,"end":74,"target":"t:tmux_buffer:capabilities/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"capabilities()","returnsReferences":[{"start":0,"end":12,"target":"t:tmux_buffer:capabilities/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe version differences without I/O. This does not qualify an untested release. `paste/3` uses paste_sanitize to gate sanitization and render raw paste.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3\">>), ok.\nok\n2> tmux_buffer:capabilities(V).\n#{paste_sanitize => false,cleaned_names => false,\n  rename_replaces => false,strict_named_target => false}"}]},"source":{"line":55,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-capabilities-1"},{"id":"tmux_buffer:delete/2","publicId":"tmux_buffer:delete/2","qualifiedName":"tmux_buffer:delete/2","name":"delete/2","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"delete(Server, Buffer)\n-spec delete(tmux_server:t(), target()) ->\n                {ok, tmux_operation:completed()} |\n                {error, map()}.","references":[{"start":36,"end":49,"target":"t:tmux_server:t/0"},{"start":53,"end":59,"target":"t:tmux_buffer:target/0"},{"start":87,"end":111,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":141,"end":144,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Delete a named buffer or latest. Missing buffers return buffer_not_found. This performs I/O and affects the server-wide buffer store.","body":"On 3.3/3.3a, named deletion first checks existence with a zero-output `show/3`\nread because native deletion falls back to the newest buffer when a name is\nabsent. This check does not collect a payload or depend on the list bounds.\nIt is not atomic: concurrent removal after the check can trigger that fallback.\nUse external serialization or tmux 3.4+ when that race is unacceptable."},"source":{"line":126,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-delete-2"},{"id":"tmux_buffer:list/1","publicId":"tmux_buffer:list/1","qualifiedName":"tmux_buffer:list/1","name":"list/1","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"list(Server)\n-spec list(tmux_server:t()) ->\n              {ok, [info()]} | {error, map()}.","references":[{"start":24,"end":37,"target":"t:tmux_server:t/0"},{"start":64,"end":68,"target":"t:tmux_buffer:info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":83,"end":86,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, [info()]} | {error, map()}","returnsReferences":[{"start":6,"end":10,"target":"t:tmux_buffer:info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture metadata in tmux's newest-first insertion order. Renaming preserves position; replacing data through `load/3` inserts a new buffer. Length frames preserve names containing delimiters, newlines or invalid UTF-8 on releases that permit them. Returns an ordinary list, bounded to 4096 rows and 1 MiB of encoded output. No payloads, hidden refresh or atomic snapshot is provided."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-list-1"},{"id":"tmux_buffer:load/3","publicId":"tmux_buffer:load/3","qualifiedName":"tmux_buffer:load/3","name":"load/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"load(Server, Name, Bytes)\n-spec load(tmux_server:t(),\n           binary() | automatic,\n           binary()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":37,"end":50,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":65,"end":71,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":98,"end":104,"target":"t:erlang:binary/0"},{"start":130,"end":154,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":182,"end":185,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Name","type":"binary() | automatic","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Bytes","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Load binary bytes under a name, or create an automatic buffer. Input may contain NUL. Empty input succeeds without changing the buffer store, including an existing name. The command payload, including argv and stdin, must fit the endpoint's 256 KiB admission limit. See `tmux_server:command/3`.","body":"Returns the completed command result, not a persistent buffer handle. No\nclipboard write is requested. Native stored-name rules still apply."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-load-3"},{"id":"tmux_buffer:paste/3","publicId":"tmux_buffer:paste/3","qualifiedName":"tmux_buffer:paste/3","name":"paste/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"paste(Pane, Buffer, Options)\n-spec paste(tmux_model:pane(), target(), paste_options()) ->\n               {ok, tmux_operation:completed()} |\n               {error, map()}.","references":[{"start":41,"end":56,"target":"t:tmux_model:pane/0"},{"start":60,"end":66,"target":"t:tmux_buffer:target/0"},{"start":70,"end":83,"target":"t:tmux_buffer:paste_options/0"},{"start":110,"end":134,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":163,"end":166,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]},{"name":"Options","type":"paste_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_buffer:paste_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send a named buffer or latest to a registered pane. Defaults preserve payload bytes: LF separators and unsanitized input. On tmux 3.7+, raw paste uses -S; sanitize=true selects its safe print encoding. Earlier releases reject that request with unsupported_capability before dispatch.","body":"separator is NUL-free; delete removes the buffer after the native paste call.\nbracketed adds markers only if the target has enabled that terminal mode.\nNative input-off/dead-pane behavior still applies. Completion establishes the\ntmux command result, not consumption by the child. No automatic retry occurs."},"source":{"line":167,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-paste-3"},{"id":"tmux_buffer:rename/3","publicId":"tmux_buffer:rename/3","qualifiedName":"tmux_buffer:rename/3","name":"rename/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Server, Old, New)\n-spec rename(tmux_server:t(), binary(), binary()) ->\n                {ok, tmux_operation:completed()} |\n                {error, map()}.","references":[{"start":38,"end":51,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":65,"end":71,"target":"t:erlang:binary/0"},{"start":99,"end":123,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":153,"end":156,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Old","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"New","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename one explicit name. tmux 3.3 refuses an occupied destination; 3.4+ replaces it. This is native collision behavior, not an atomic absence check. Identical input names return same_buffer_name before I/O, avoiding unsafe legacy tmux paths. New names retain native cleaning rules; see `list/1` for stored names. The same observed 3.3/3.3a missing-name preflight and race as `delete/2` apply."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-rename-3"},{"id":"tmux_buffer:show/2","publicId":"tmux_buffer:show/2","qualifiedName":"tmux_buffer:show/2","name":"show/2","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"show(Server, Buffer)\n-spec show(tmux_server:t(), target()) ->\n              {ok, binary()} | {error, map()}.","references":[{"start":32,"end":45,"target":"t:tmux_server:t/0"},{"start":49,"end":55,"target":"t:tmux_buffer:target/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":81,"end":87,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":101,"end":104,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read exact payload bytes with default bounds. See `show/3` for limits."},"source":{"line":81,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-show-2"},{"id":"tmux_buffer:show/3","publicId":"tmux_buffer:show/3","qualifiedName":"tmux_buffer:show/3","name":"show/3","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"function","modifiers":[],"signatures":[{"raw":"show(Server, Buffer, Options)\n-spec show(tmux_server:t(), target(), read_options()) ->\n              {ok, binary()} | {error, map()}.","references":[{"start":41,"end":54,"target":"t:tmux_server:t/0"},{"start":58,"end":64,"target":"t:tmux_buffer:target/0"},{"start":68,"end":80,"target":"t:tmux_buffer:read_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":106,"end":112,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":126,"end":129,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Buffer","type":"target()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_buffer:target/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_buffer:read_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read exact payload bytes from an unattached one-shot client. No print decoding or newline removal applies. max_bytes is 0 through 1 MiB; exceeding it returns output_limit with partial command evidence, never a successful truncated value. deadline_ms is 1 through 600000. Missing buffers return buffer_not_found."},"source":{"line":90,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_buffer-show-3"},{"id":"t:tmux_buffer:capabilities/0","publicId":"t:tmux_buffer:capabilities/0","qualifiedName":"tmux_buffer:capabilities/0","name":"capabilities/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capabilities() ::\n          #{paste_sanitize := boolean(),\n            cleaned_names := boolean(),\n            rename_replaces := boolean(),\n            strict_named_target := boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":54,"end":61,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":94,"end":101,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":136,"end":143,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":182,"end":189,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-defined buffer behavior for a parsed daemon version."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_buffer-capabilities-0"},{"id":"t:tmux_buffer:info/0","publicId":"t:tmux_buffer:info/0","qualifiedName":"tmux_buffer:info/0","name":"info/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type info() ::\n          #{name := binary(),\n            size := non_neg_integer(),\n            created := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":36,"end":42,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":108,"end":123,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Captured name, payload byte count and Unix creation time; not a live handle."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_buffer-info-0"},{"id":"t:tmux_buffer:paste_options/0","publicId":"t:tmux_buffer:paste_options/0","qualifiedName":"tmux_buffer:paste_options/0","name":"paste_options/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type paste_options() ::\n          #{separator => binary(),\n            delete => boolean(),\n            bracketed => boolean(),\n            sanitize => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":50,"end":56,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":82,"end":89,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":118,"end":125,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":153,"end":160,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Paste controls. separator defaults to LF; delete and bracketed default to false. sanitize defaults to false, preserving bytes. Explicit sanitization requires tmux 3.7+. Bracketing occurs only when the pane enables bracketed paste."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_buffer-paste_options-0"},{"id":"t:tmux_buffer:read_options/0","publicId":"t:tmux_buffer:read_options/0","qualifiedName":"tmux_buffer:read_options/0","name":"read_options/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type read_options() ::\n          #{max_bytes => 0..1048576,\n            deadline_ms => 1..600000}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read bounds: max_bytes defaults to 1 MiB; deadline_ms defaults to 2500."},"source":{"line":30,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_buffer-read_options-0"},{"id":"t:tmux_buffer:target/0","publicId":"t:tmux_buffer:target/0","qualifiedName":"tmux_buffer:target/0","name":"target/0","namespace":"tmux_buffer","parent":"tmux_buffer","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type target() :: binary() | latest.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":18,"end":24,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A stored buffer name, or latest to let tmux select its newest buffer."},"source":{"line":26,"file":"apps/libtmux_erlang/src/tmux_buffer.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_buffer-target-0"},{"id":"tmux_capability","publicId":"tmux_capability","qualifiedName":"tmux_capability","name":"tmux_capability","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Look up source-derived native command declarations and feature minimums.","body":"`commands/1` and `command/2` describe the exact source profiles in `profiles/0`.\nProfiles cover every release in the supported tmux 3.3a–3.8 range. They do not\ncontact tmux, interpret its arguments or qualify another build.\nCanonical command names are lookup keys; aliases remain metadata. A native\ndeclaration does not mean this library provides a typed facade for it. Use\n`tmux_command:raw/2` for an explicit trusted command.\n\n`describe/1` reports selected native feature minimums. `require/2` compares a\nparsed version with one of those minimums; it does not perform I/O or dispatch\nthe command. Numeric minimum checks also accept uncatalogued and tracking\nversions, preserving the distinction from exact parser discovery. They do not\nestablish runtime or CI qualification. Use `tmux_server:version/1` to obtain the\nversion captured by a registered endpoint.\n\nThe [generated reference](commands-reference.md) records source profiles and\nparser declarations. Maintaining the catalogue needs a tmux source checkout;\ninstalled consumers use compiled data and OTP only."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability"},{"id":"tmux_capability:command/2","publicId":"tmux_capability:command/2","qualifiedName":"tmux_capability:command/2","name":"command/2","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"command(Version, Name)\n-spec command(tmux_version:t(), binary()) ->\n                 {ok, command_info()} | {error, map()}.","references":[{"start":37,"end":51,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"start":90,"end":102,"target":"t:tmux_capability:command_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":116,"end":119,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, command_info()} | {error, map()}","returnsReferences":[{"start":5,"end":17,"target":"t:tmux_capability:command_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up one canonical native command in an exact source profile. Returns unknown_command for aliases or unknown names, unsupported_command when a known command is absent from that profile, and unsupported_command_catalogue for uncatalogued or tracking versions. Performs no I/O.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3a\">>), ok.\nok\n2> {ok, C} = tmux_capability:command(V, <<\"send-keys\">>), ok.\nok\n3> maps:get(file, maps:get(source, C)).\n<<\"cmd-send-keys.c\">>"}]},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability-command-2"},{"id":"tmux_capability:commands/1","publicId":"tmux_capability:commands/1","qualifiedName":"tmux_capability:commands/1","name":"commands/1","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"commands(Version)\n-spec commands(tmux_version:t()) ->\n                  {ok, [binary()]} | {error, map()}.","references":[{"start":33,"end":47,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":78,"end":84,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":99,"end":102,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"{ok, [binary()]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return sorted canonical command names for an exact catalogued stable version. Tracking and uncatalogued versions return unsupported_command_catalogue. This is pure source discovery; it does not execute list-commands."},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability-commands-1"},{"id":"tmux_capability:describe/1","publicId":"tmux_capability:describe/1","qualifiedName":"tmux_capability:describe/1","name":"describe/1","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"describe/1\n-spec describe(feature()) ->\n                  {ok, feature_info()} | {error, map()}.","references":[{"start":26,"end":33,"target":"t:tmux_capability:feature/0"},{"start":63,"end":75,"target":"t:tmux_capability:feature_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"}],"params":[{"name":"Feature","type":"feature()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_capability:feature/0"}]}],"returns":"{ok, feature_info()} | {error, map()}","returnsReferences":[{"start":5,"end":17,"target":"t:tmux_capability:feature_info/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a selected native feature's source-derived minimum and sampled profiles. Unknown features return unknown_capability. Performs no I/O; `require/2` applies the minimum to a parsed version."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability-describe-1"},{"id":"tmux_capability:profiles/0","publicId":"tmux_capability:profiles/0","qualifiedName":"tmux_capability:profiles/0","name":"profiles/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"profiles()\n-spec profiles() -> [binary()].","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":32,"end":38,"target":"t:erlang:binary/0"}],"params":[],"returns":"[binary()]","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"List the exact source profile names in catalogue order. Performs no I/O."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability-profiles-0"},{"id":"tmux_capability:require/2","publicId":"tmux_capability:require/2","qualifiedName":"tmux_capability:require/2","name":"require/2","namespace":"tmux_capability","parent":"tmux_capability","kind":"function","modifiers":[],"signatures":[{"raw":"require(Version, Feature)\n-spec require(tmux_version:t(), feature()) ->\n                 ok | {error, map()}.","references":[{"start":40,"end":54,"target":"t:tmux_version:t/0"},{"start":58,"end":65,"target":"t:tmux_capability:feature/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":102,"end":105,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Feature","type":"feature()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_capability:feature/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Require a native feature's numeric major/minor floor without dispatching I/O. An older version returns unsupported_capability with capability and minimum. Patch letters and tracking markers do not promote an older minor version. Unknown features and malformed parsed versions return distinct errors.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.4\">>), ok.\nok\n2> tmux_capability:require(V, send_client_keys).\nok"}]},"source":{"line":122,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_capability-require-2"},{"id":"t:tmux_capability:command_info/0","publicId":"t:tmux_capability:command_info/0","qualifiedName":"tmux_capability:command_info/0","name":"command_info/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_info() ::\n          #{alias := binary() | none,\n            argument_spec := binary(),\n            min_args := non_neg_integer(),\n            max_args := non_neg_integer() | none,\n            source :=\n                #{file := binary(),\n                  commit := binary(),\n                  sha256 := binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":45,"end":51,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":91,"end":97,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":125,"end":140,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":168,"end":183,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":242,"end":248,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":280,"end":286,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":318,"end":324,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native alias, flag declaration and positional bounds, with the exact source file, commit and SHA-256. none means no alias or an unbounded positional upper limit. Additional argument callbacks and runtime checks remain tmux's concern."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_capability-command_info-0"},{"id":"t:tmux_capability:feature/0","publicId":"t:tmux_capability:feature/0","qualifiedName":"tmux_capability:feature/0","name":"feature/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type feature() ::\n          native_list_filter | send_client_keys |\n          key_list_format | layout_json.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Selected native capabilities; these do not introduce new typed command options."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_capability-feature-0"},{"id":"t:tmux_capability:feature_info/0","publicId":"t:tmux_capability:feature_info/0","qualifiedName":"tmux_capability:feature_info/0","name":"feature_info/0","namespace":"tmux_capability","parent":"tmux_capability","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type feature_info() ::\n          #{minimum :=\n                {non_neg_integer(), non_neg_integer()},\n            commands := [binary()],\n            description := binary(),\n            versions := [binary()]}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":64,"end":79,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":83,"end":98,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":128,"end":134,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":166,"end":172,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":201,"end":207,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-sampled profiles, native commands, description and numeric minimum."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_capability.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_capability-feature_info-0"},{"id":"tmux_command","publicId":"tmux_command","qualifiedName":"tmux_command","name":"tmux_command","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Build tmux commands and bounded sequences without performing I/O.","body":"Arguments remain binary values. Rendering protects trailing semicolons from\ntmux's command separator parser. This is distinct from shell quoting and from\nformat expansion. A raw command is trusted application code; external services\nmust apply their own command allowlist and write policy.\n\nUse `literal_format/1` only for a whole argument that tmux\nexpands as a format, such as a new name or cwd. It does not encode a value\nnested in a format expression. tmux's stored-name escaping and session-name\nsubstitutions still apply. Use `literal_format/2` with mode time\nfor commands such as display-message that also expand strftime percent\ndirectives. This protects one format-expansion pass, not later visual style\nrendering or recursive/nested expansion. No renderer reverses stored-name\nsemantics.\n\n`launch/1` distinguishes executable argv from an explicitly\nrequested shell command. A singleton argv uses the installed helper's\nexec-only mode because tmux otherwise passes one argument to its default\nshell. Empty argv is invalid; default_shell explicitly requests tmux's\nconfigured default command/shell. The internal helper uses an absolute path so\na child's cwd does not change helper resolution. Relative executable arguments\nretain their native meaning.\n\nEmpty shell commands have command-specific lifetime. split-window creates a\nprocess-free pane. new-session executes an empty shell command and can remove\nthe new object immediately. new-window does likewise before tmux 3.8; tmux 3.8\ncreates a process-free pane. Use a persistent job for parent sessions/windows\nthat must remain available across supported versions.\n\nSubmit commands through `tmux_server:command/3` or `tmux_operation:start/3`.\n`sequence/1` combines flat command values for one-shot execution with combined\noutput and a possible completed prefix on error.\nThe [job guide](jobs.md) shows submission, completion and cancellation.\n`tmux_session:rename_command/2` and `tmux_pane:resize_command/2` build values\nbound to their row's captured origin. Execution through another endpoint\nreturns different_owner before native work. Construction does not validate\nendpoint liveness or authorize an automatic mutation retry.\n\n`wait_for/2` builds native channel signals, waits and advisory locks.\n`source_file/2` builds configuration loading from stdin or a literal absolute\npath. Both return command values without opening an endpoint or doing I/O.\n`to_config/1` renders a command or bounded command list for native\nconfiguration input, preserving argument bytes through tmux's lexer.","examples":[{"lang":"erlang","code":"1> {ok, C} = tmux_command:raw(<<\"list-panes\">>, [<<\"-a\">>]), ok.\nok\n2> tmux_command:argv(C).\n[<<\"list-panes\">>,<<\"-a\">>]\n3> tmux_command:literal_format(<<\"api-#{pane_id}\">>).\n{ok,<<\"api-##{pane_id}\">>}\n4> tmux_command:launch(#{argv => [<<\"/bin/printf\">>, <<\"hello\">>]}).\n{ok,[<<\"/bin/printf\">>,<<\"hello\">>]}"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command"},{"id":"tmux_command:argv/1","publicId":"tmux_command:argv/1","qualifiedName":"tmux_command:argv/1","name":"argv/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"argv(Command)\n-spec argv(t()) -> [binary()].","references":[{"start":25,"end":26,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":34,"end":40,"target":"t:erlang:binary/0"}],"params":[{"name":"Command","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_command:t/0"}]}],"returns":"[binary()]","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render a validated command into executable argv, protecting trailing tmux separators. Performs no I/O and raises for an invalid command value."},"source":{"line":299,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-argv-1"},{"id":"tmux_command:launch/1","publicId":"tmux_command:launch/1","qualifiedName":"tmux_command:launch/1","name":"launch/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"launch/1\n-spec launch(launch_spec()) ->\n                {ok, [binary()]} | {error, map()}.","references":[{"start":22,"end":33,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":62,"end":68,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":83,"end":86,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"launch_spec()","typeReferences":[{"start":0,"end":11,"target":"t:tmux_command:launch_spec/0"}]}],"returns":"{ok, [binary()]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render explicit executable argv, an explicitly requested shell command, or default_shell. Singleton argv uses the installed helper's exec-only mode to avoid tmux interpreting it as shell syntax. Performs no I/O."},"source":{"line":448,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-launch-1"},{"id":"tmux_command:literal_format/1","publicId":"tmux_command:literal_format/1","qualifiedName":"tmux_command:literal_format/1","name":"literal_format/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"literal_format(Value)\n-spec literal_format(binary()) ->\n                        {ok, binary()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":85,"end":91,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":105,"end":108,"target":"t:erlang:map/0"}],"params":[{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Quote a complete literal argument for tmux format expansion. This does not encode operands nested inside another format expression. Performs no I/O."},"source":{"line":389,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-literal_format-1"},{"id":"tmux_command:literal_format/2","publicId":"tmux_command:literal_format/2","qualifiedName":"tmux_command:literal_format/2","name":"literal_format/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"literal_format/2\n-spec literal_format(binary(), tmux | time) ->\n                        {ok, binary()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":38,"end":44,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":93,"end":99,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"}],"params":[{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Mode","type":"tmux | time","typeReferences":[]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Quote a complete literal format argument. Mode tmux protects hash expansion; mode time also protects strftime percent directives. Stored-name semantics remain tmux's own. This handles one expansion pass, not a nested operand, recursive expansion or later visual style rendering. Performs no I/O.","body":"Hash runs before `[` stay unchanged because tmux preserves style-looking\nprefixes for a separate drawing step. Other hashes are doubled. In time mode,\nan argument containing percent bytes must fit tmux's 8191-byte strftime result\nlimit after hash encoding and before percent doubling; larger values return\n`format_limit` with `time_bytes` and `max_bytes`. Arguments without percent\nbytes skip that native time-expansion limit. The encoded 32 KiB command limit\nstill applies in either mode."},"source":{"line":407,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-literal_format-2"},{"id":"tmux_command:raw/2","publicId":"tmux_command:raw/2","qualifiedName":"tmux_command:raw/2","name":"raw/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"raw(Name, Arguments)\n-spec raw(binary(), [binary()]) ->\n             {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":31,"end":37,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":42,"end":48,"target":"t:erlang:binary/0"},{"start":74,"end":75,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"}],"params":[{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Arguments","type":"[binary()]","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate one trusted command name and binary argv, without I/O. The renderer protects tmux separators; it does not provide shell or nested-format quoting. External services still need their own allowlists and write policy. Names are at most 128 bytes. NUL bytes are rejected, and at most 2,040 arguments fit within a 32 KiB command reservation including framing overhead."},"source":{"line":100,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-raw-2"},{"id":"tmux_command:sequence/1","publicId":"tmux_command:sequence/1","qualifiedName":"tmux_command:sequence/1","name":"sequence/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"sequence/1\n-spec sequence([t(), ...]) -> {ok, t()} | {error, map()}.","references":[{"start":27,"end":28,"target":"t:tmux_command:t/0"},{"start":46,"end":47,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":61,"end":64,"target":"t:erlang:map/0"}],"params":[{"name":"Commands","type":"[t(), ...]","typeReferences":[{"start":1,"end":2,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build one bounded native command sequence without I/O. Members must be a nonempty flat list of at most 256 command values. Their combined executable argv is limited to 2041 words and 32 KiB including separator overhead. Arguments keep the literal separator protection of `raw/2`; only boundaries between members become native command separators in `argv/1`.","body":"Captured members must share an endpoint origin. That origin also binds the\nsequence; raw members use the caller's explicitly selected endpoint. Submit\nthrough `tmux_server:command/3` or `tmux_operation:start/3`.\n\nExecution is not atomic. A failed member can leave a completed prefix, and\ncommands can wait or interleave with other work. The one-shot result contains\ncombined bounded stdout/stderr and native exit status, without per-member\ncompletion attribution or rollback. Control-mode eligibility is separate.\n`to_config/1` can serialize a sequence with the same origin-loss policy as\nother configuration text."},"source":{"line":129,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-sequence-1"},{"id":"tmux_command:source_file/2","publicId":"tmux_command:source_file/2","qualifiedName":"tmux_command:source_file/2","name":"source_file/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"source_file(Source, Options)\n-spec source_file(source(), source_options()) ->\n                     {ok, t()} | {error, map()}.","references":[{"start":47,"end":53,"target":"t:tmux_command:source/0"},{"start":57,"end":71,"target":"t:tmux_command:source_options/0"},{"start":104,"end":105,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":119,"end":122,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"source()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_command:source/0"}]},{"name":"Options","type":"source_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:source_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build configuration loading from stdin or one literal absolute path, without I/O. `stdin` renders `source-file -`; supply configuration bytes in the `stdin` option of `tmux_server:command/3` or `tmux_operation:start/3`. Those APIs bound input to 256 KiB including their argument reservation.","body":"Paths are NUL-free POSIX byte binaries. Glob metacharacters and backslashes\nare escaped so only that filename is selected; format expansion is disabled.\nThe combined encoded path and flags must fit `raw/2` limits. The file is read\nby tmux at execution time; this builder does not open it or bound its size.\n\n`parse_only` requests native `-n` parsing without executing the configuration's\ncommand list. `quiet` requests native `-q` missing-file suppression; it does\nnot suppress syntax or execution errors. Both default to false. Configuration\nis trusted tmux code, with its own variable, directive and command semantics.\nParse-only is not a sandbox. Execution can partially change server state before\nan error; cancellation cannot undo those effects. Completion does not prove\nthat background jobs launched by the configuration have finished.","examples":[{"lang":"erlang","code":"1> {ok, Source} = tmux_command:source_file(stdin, #{parse_only => true}), ok.\nok\n2> tmux_command:argv(Source).\n[<<\"source-file\">>,<<\"-n\">>,<<\"--\">>,<<\"-\">>]"}]},"source":{"line":228,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-source_file-2"},{"id":"tmux_command:to_config/1","publicId":"tmux_command:to_config/1","qualifiedName":"tmux_command:to_config/1","name":"to_config/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"to_config/1\n-spec to_config(t() | [t(), ...]) ->\n                   {ok, binary()} | {error, map()}.","references":[{"start":28,"end":29,"target":"t:tmux_command:t/0"},{"start":35,"end":36,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":73,"end":79,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"t() | [t(), ...]","typeReferences":[{"start":0,"end":1,"target":"t:tmux_command:t/0"},{"start":7,"end":8,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Render validated commands as native configuration text, without I/O. Accepts one command, a `sequence/1` value, or a nonempty flat list of at most 256 commands. Returns an ASCII binary of at most 32 KiB, without a final newline. Validation uses `validate/1`; escaping growth, command count and aggregate size can return `command_limit`. Lists use native command separators between independently quoted commands. Rendering does not execute them or provide atomic execution or rollback. The text carries no origin token; executing serialized configuration requires the caller to choose and validate its destination explicitly.","body":"Each argument is doublequoted. Quote, backslash, dollar, tilde, control and\nnon-ASCII bytes use three-digit octal escapes. Empty arguments, semicolons,\nnewlines and non-UTF-8 byte values remain argument data. The lexer does not\nexpand their variables or tilde prefixes, strip newline indentation, or\ninterpret them as directives, comments or additional commands.\n\nProtection covers one lexer pass. Native command-string arguments, including\n`bind-key` and `set-hook` values, can be parsed again by the receiving command.\nRender each inner command string separately for its own parse boundary.\n\nThis is tmux configuration syntax, separate from `argv/1` executable arguments\nand shell quoting. Native commands still interpret their values and expand\nformats as usual; `literal_format/2` handles that separate boundary when\nliteral format values are required. Load the text explicitly with\n`source_file/2`, or store it through a native command that accepts configuration\ntext. The [configuration guide](configuration.md) uses this renderer with\nexplicit execution and completion signals."},"source":{"line":340,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-to_config-1"},{"id":"tmux_command:validate/1","publicId":"tmux_command:validate/1","qualifiedName":"tmux_command:validate/1","name":"validate/1","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"validate/1\n-spec validate(term()) -> {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":26,"end":30,"target":"t:erlang:term/0"},{"start":42,"end":43,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":57,"end":60,"target":"t:erlang:map/0"}],"params":[{"name":"Argument1","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Revalidate a command value at a submission boundary. Returns a compact validated command or a tagged shape/argument/resource error, without I/O."},"source":{"line":252,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-validate-1"},{"id":"tmux_command:wait_for/2","publicId":"tmux_command:wait_for/2","qualifiedName":"tmux_command:wait_for/2","name":"wait_for/2","namespace":"tmux_command","parent":"tmux_command","kind":"function","modifiers":[],"signatures":[{"raw":"wait_for(Channel, Action)\n-spec wait_for(binary(), wait_action()) ->\n                  {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":51,"end":62,"target":"t:tmux_command:wait_action/0"},{"start":92,"end":93,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":107,"end":110,"target":"t:erlang:map/0"}],"params":[{"name":"Channel","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Action","type":"wait_action()","typeReferences":[{"start":0,"end":11,"target":"t:tmux_command:wait_action/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a native `wait-for` command without I/O. Channels are nonempty NUL-free binary names, subject to the command reservation in `raw/2`; neither shell nor format expansion occurs. Submit through `tmux_operation:start/3` for a wait that leaves the caller free, or through `tmux_server:command/3` to await it.","body":"`signal` wakes current waiters. On an unlocked channel with no waiters or\npending wakeup, it retains one wakeup for a later wait. Signaling that channel\nagain before a wait can clear the pending state. Signals are neither counted\nnor reliably coalesced events; send once per expected wait. Channel names are\nshared by all clients of the server. Use separate names for signaling and\nlocking. `lock` acquires an advisory channel lock or waits\nfor an explicit `unlock`; a completed command client's exit does not release\nits acquired lock. Unlocking an unlocked channel is a native command error.\n\nCancellation retires the library client. It does not undo a signal or release\na lock that may already have been acquired; an uncertain lock outcome needs\napplication coordination before another unlock. This is not an owned mutex.","examples":[{"lang":"erlang","code":"1> {ok, Signal} = tmux_command:wait_for(<<\"build-ready\">>, signal), ok.\nok\n2> tmux_command:argv(Signal).\n[<<\"wait-for\">>,<<\"-S\">>,<<\"--\">>,<<\"build-ready\">>]"}]},"source":{"line":188,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_command-wait_for-2"},{"id":"t:tmux_command:launch_spec/0","publicId":"t:tmux_command:launch_spec/0","qualifiedName":"tmux_command:launch_spec/0","name":"launch_spec/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type launch_spec() ::\n          default_shell |\n          #{argv := [binary(), ...]} |\n          #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":70,"end":76,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":109,"end":115,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicit executable argv, an explicitly requested shell command, or tmux's configured default shell."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-launch_spec-0"},{"id":"t:tmux_command:respawn_spec/0","publicId":"t:tmux_command:respawn_spec/0","qualifiedName":"tmux_command:respawn_spec/0","name":"respawn_spec/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_spec() ::\n          previous |\n          #{argv := [binary(), ...]} |\n          #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":66,"end":72,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":105,"end":111,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Reuse tmux's saved command/shell, or replace it with argv or a shell command. Used by `tmux_pane:respawn/2` and `tmux_window:respawn/2`."},"source":{"line":81,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-respawn_spec-0"},{"id":"t:tmux_command:source/0","publicId":"t:tmux_command:source/0","qualifiedName":"tmux_command:source/0","name":"source/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source() :: stdin | binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":26,"end":32,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Standard input, or one literal absolute POSIX byte path with no NUL."},"source":{"line":68,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-source-0"},{"id":"t:tmux_command:source_options/0","publicId":"t:tmux_command:source_options/0","qualifiedName":"tmux_command:source_options/0","name":"source_options/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_options() ::\n          #{parse_only => boolean(), quiet => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":52,"end":59,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":72,"end":79,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native parse-only and quiet-missing-file flags; both default to false."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-source_options-0"},{"id":"t:tmux_command:t/0","publicId":"t:tmux_command:t/0","qualifiedName":"tmux_command:t/0","name":"t/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated command or flat sequence. Rendering and execution remain separate. Domain builders retain a captured endpoint origin; raw values are unbound."},"source":{"line":87,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-t-0"},{"id":"t:tmux_command:wait_action/0","publicId":"t:tmux_command:wait_action/0","qualifiedName":"tmux_command:wait_action/0","name":"wait_action/0","namespace":"tmux_command","parent":"tmux_command","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type wait_action() :: wait | signal | lock | unlock.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native wait channel action. lock/unlock are explicit advisory operations, not owned leases."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_command.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_command-wait_action-0"},{"id":"tmux_control","publicId":"tmux_control","qualifiedName":"tmux_control","name":"tmux_control","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Own an explicit persistent tmux control attachment.","body":"`attach/3` attaches to an existing session from `m:tmux_server` and verifies\nthe daemon identity on that connection. The caller owns its lifetime.\nAttachment changes the session's attached-client count. The command client\nuses no-output and ignore-size; -E skips attachment's environment update.\nThe library issues no session-option writes or session-creation commands.\nConfigured hooks and native lifetime policies can still change state,\nincluding on failed attach or detachment. Those effects are not rolled back.\nCommand submission and terminal streaming are not yet exposed.\n\nUse `close/1` before closing the parent endpoint. Parent closing, invalidation\nor caller death requests retirement, but parent close alone does not prove\nthis client's exit. Control close and `status/1` report its native cleanup.\nNeither detachment nor cancellation reverses remote effects. Application\nshutdown alone is not a verified cleanup result."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_control"},{"id":"tmux_control:attach/3","publicId":"tmux_control:attach/3","qualifiedName":"tmux_control:attach/3","name":"attach/3","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"attach(Server, Session, Options)\n-spec attach(tmux_server:t(),\n             tmux_model:session(),\n             attach_options()) ->\n                {ok, t()} | {error, map()}.","references":[{"start":46,"end":59,"target":"t:tmux_server:t/0"},{"start":76,"end":94,"target":"t:tmux_model:session/0"},{"start":111,"end":125,"target":"t:tmux_control:attach_options/0"},{"start":153,"end":154,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":168,"end":171,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"attach_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_control:attach_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Attach to an existing captured session from this exact endpoint origin. Performs I/O and waits for a same-connection identity probe. Uses attach-session with -E rather than creating a session or writing options. Configured hooks may change state; failure does not reverse their effects. The control client affects attached_count. Unexpected hook-generated reply blocks fail attachment and retire the client.","body":"An attachment timeout requests cleanup. If cleanup cannot be proved within\nits finite deadline, the error includes a control handle for `close/1` recovery.\nThe supervised owner remains until native retirement. Close explicitly to\nobserve cleanup, including when the parent endpoint is already closed."},"source":{"line":55,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_control-attach-3"},{"id":"tmux_control:close/1","publicId":"tmux_control:close/1","qualifiedName":"tmux_control:close/1","name":"close/1","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"close(Control)\n-spec close(t()) -> ok | {error, map()}.","references":[{"start":27,"end":28,"target":"t:tmux_control:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":48,"end":51,"target":"t:erlang:map/0"}],"params":[{"name":"Control","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_control:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Retire this control client and its helper without issuing session or daemon destruction commands. Native lifetime policies and detachment hooks may still change state; cleanup does not reverse their effects. Returns ok only after actual retirement. A finite cleanup failure leaves a supervised owner for retry and observation. Successful close is idempotent during the 60-second handle retention period."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_control-close-1"},{"id":"tmux_control:status/1","publicId":"tmux_control:status/1","qualifiedName":"tmux_control:status/1","name":"status/1","namespace":"tmux_control","parent":"tmux_control","kind":"function","modifiers":[],"signatures":[{"raw":"status(Control)\n-spec status(t()) -> {ok, state()} | {error, map()}.","references":[{"start":29,"end":30,"target":"t:tmux_control:t/0"},{"start":42,"end":47,"target":"t:tmux_control:state/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":61,"end":64,"target":"t:erlang:map/0"}],"params":[{"name":"Control","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_control:t/0"}]}],"returns":"{ok, state()} | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_control:state/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":24,"end":27,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read retained connection state without a tmux command. Inspect cleanup rather than inferring native exit from the Erlang owner's lifecycle. Closed handles expire after 60 seconds and then return control_expired."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_control-status-1"},{"id":"t:tmux_control:attach_options/0","publicId":"t:tmux_control:attach_options/0","qualifiedName":"tmux_control:attach_options/0","name":"attach_options/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type attach_options() ::\n          #{startup_timeout_ms => 1..600000}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Finite attachment budget, including parent registration, exec and identity. Defaults to 2500 ms."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_control-attach_options-0"},{"id":"t:tmux_control:state/0","publicId":"t:tmux_control:state/0","qualifiedName":"tmux_control:state/0","name":"state/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := attaching | open | closing | closed,\n            generation := reference(),\n            owner := pid(),\n            identity := unverified | same_connection,\n            cleanup := pending | incomplete | complete,\n            child_pid := none | pos_integer(),\n            helper_pid := none | pos_integer(),\n            cause := none | atom()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":101,"end":110,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":135,"end":138,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":284,"end":295,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":332,"end":343,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":375,"end":379,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Connection state, separate from command completion. complete proves native client/helper retirement; pending and incomplete do not. Retained PIDs are diagnostic observations, never permission to signal a process."},"source":{"line":35,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_control-state-0"},{"id":"t:tmux_control:t/0","publicId":"t:tmux_control:t/0","qualifiedName":"tmux_control:t/0","name":"t/0","namespace":"tmux_control","parent":"tmux_control","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A generation-bound connection handle. Passing it does not transfer lifetime ownership."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_control.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_control-t-0"},{"id":"tmux_error","publicId":"tmux_error","qualifiedName":"tmux_error","name":"tmux_error","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Explain library exceptions through Erlang's native error formatter.","body":"The shell and `erl_error:format_exception/3` call `format_error/2` through\nEEP-54 stack metadata. Explanations supplement the original exception reason;\ntagged results from `tmux_filter:new/2` and `tmux_select:try_where/2` retain\ntheir existing structured data. Formatting performs no tmux I/O.\n\nOnly library-raised errors carry this metadata. Application callback failures\nretain their original class, reason and stack. Coverage errors describe missing\nobservations; formatting never loads those observations or retries an action.\nLong detail values may be abbreviated in the explanation. The exception reason\nretains the original error data. See [runtime diagnostics](diagnostics.md) for\nthe separate, bounded Logger report contract."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_error.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_error"},{"id":"tmux_error:format_error/2","publicId":"tmux_error:format_error/2","qualifiedName":"tmux_error:format_error/2","name":"format_error/2","namespace":"tmux_error","parent":"tmux_error","kind":"function","modifiers":[],"signatures":[{"raw":"format_error/2\n-spec format_error(term(), erlang:stacktrace()) ->\n                      #{general => unicode:chardata()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":34,"end":38,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":42,"end":59,"target":"t:erlang:stacktrace/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/unicode.html#t:chardata/0","project":"Erlang/OTP"},"start":101,"end":117,"target":"t:unicode:chardata/0"}],"params":[{"name":"Argument1","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Argument2","type":"erlang:stacktrace()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":0,"end":17,"target":"t:erlang:stacktrace/0"}]}],"returns":"#{general => unicode:chardata()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/unicode.html#t:chardata/0","project":"Erlang/OTP"},"start":13,"end":29,"target":"t:unicode:chardata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return supplemental native error text, or an empty map for an unknown reason.","body":"This is the `c:erl_error:format_error/2` callback. It neither changes the\nexception nor catches it on behalf of a caller.","examples":[{"lang":"erlang","code":"1> #{general := Text} = tmux_error:format_error({bad_query_limit, -1}, []), ok.\nok\n2> unicode:characters_to_binary(Text).\n<<\"The query limit must be an integer from 0 through 65536.\">>"}]},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_error.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_error-format_error-2"},{"id":"tmux_filter","publicId":"tmux_filter","qualifiedName":"tmux_filter","name":"tmux_filter","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Construct portable conditions and prepare them against captured values.","body":"Local criteria use atom keys, binary text and schema-typed values. Fields and\noperators conjoin. Boolean branches use 'and', 'or' and 'not'; relationships\nuse some/every/none/count or is/is_not. Validation examines the entire input\nbefore evaluation. No function here performs tmux I/O. Use portable filters\nwith `tmux_select:where/2` or `tmux_query:where/2`; the [query\nguide](querying.md) explains their different execution boundaries.\n\nWire version 1 uses generated camelCase field names, snake_case operators,\nJSON null for known absence and {\"base64\": \"...\"} for byte operands. Byte\nvalues never become text implicitly. Regex uses the restricted ASCII\nportable_v1 dialect, absolute anchors and no flags. Preparation compiles each\npattern once. Non-ASCII subjects and exhausted match limits return errors.\n\nBoth input criteria and their normalized wire document must fit the grammar,\ndepth and byte limits. Resource errors can refer to the canonical wire path.","examples":[{"lang":"erlang","code":"1> Fields = #{id => <<\"%1\">>, current_command => <<\"vim\">>}, ok.\nok\n2> {ok, P} = tmux_model:pane(Fields), S = tmux_select:from_list(pane, [P]), ok.\nok\n3> R = #{pattern => <<\"^(vim|nvim)$\">>, dialect => portable_v1}, ok.\nok\n4> tmux_select:size(tmux_select:where(#{current_command => #{regex => R}}, S)).\n1"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter"},{"id":"tmux_filter:decode_json/1","publicId":"tmux_filter:decode_json/1","qualifiedName":"tmux_filter:decode_json/1","name":"decode_json/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"decode_json(Binary)\n-spec decode_json(binary()) ->\n                     {ok, json:decode_value()} |\n                     {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":38,"end":44,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":77,"end":94,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":129,"end":132,"target":"t:erlang:map/0"}],"params":[{"name":"Binary","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, json:decode_value()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":5,"end":22,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Decode bounded external JSON with duplicate-key, trailing-input and depth checks. Returns tagged errors with input paths. Parsing does not execute tmux or choose application modules."},"source":{"line":135,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-decode_json-1"},{"id":"tmux_filter:entity/1","publicId":"tmux_filter:entity/1","qualifiedName":"tmux_filter:entity/1","name":"entity/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"entity/1\n-spec entity(t()) -> tmux_schema:entity().","references":[{"start":22,"end":23,"target":"t:tmux_filter:t/0"},{"start":30,"end":48,"target":"t:tmux_schema:entity/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"tmux_schema:entity()","returnsReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the schema entity this portable filter accepts, without I/O."},"source":{"line":141,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-entity-1"},{"id":"tmux_filter:from_wire/2","publicId":"tmux_filter:from_wire/2","qualifiedName":"tmux_filter:from_wire/2","name":"from_wire/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"from_wire(Entity, Document)\n-spec from_wire(tmux_schema:entity(), term()) ->\n                   {ok, t()} | {error, map()}.","references":[{"start":44,"end":62,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":66,"end":70,"target":"t:erlang:term/0"},{"start":101,"end":102,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":116,"end":119,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Document","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate a versioned filter document using generated wire-name allowlists. Rejects unknown fields, operators, wrong entity/version and resource limits. No payload key becomes an atom; this does not execute a query."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-from_wire-2"},{"id":"tmux_filter:matches/2","publicId":"tmux_filter:matches/2","qualifiedName":"tmux_filter:matches/2","name":"matches/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"matches(Prepared, Row)\n-spec matches(prepared(), tmux_model:row()) ->\n                 {ok, boolean()} | {error, map()}.","references":[{"start":37,"end":45,"target":"t:tmux_filter:prepared/0"},{"start":49,"end":63,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":92,"end":99,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"}],"params":[{"name":"Prepared","type":"prepared()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_filter:prepared/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]}],"returns":"{ok, boolean()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":5,"end":12,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":26,"end":29,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Evaluate an unmodified captured row against a prepared filter. Returns a Boolean result or tagged context/regex resource error. It performs no tmux I/O and never converts evaluation failure into a nonmatch."},"source":{"line":223,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-matches-2"},{"id":"tmux_filter:new/2","publicId":"tmux_filter:new/2","qualifiedName":"tmux_filter:new/2","name":"new/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"new/2\n-spec new(tmux_schema:entity(), map() | t()) ->\n             {ok, t()} | {error, map()}.","references":[{"start":16,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"start":46,"end":47,"target":"t:tmux_filter:t/0"},{"start":72,"end":73,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":87,"end":90,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Filter","type":"map() | t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":9,"target":"t:tmux_filter:t/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_filter:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria or reuse an already normalized filter for the same entity.","examples":[{"lang":"erlang","code":"1> {ok, F} = tmux_filter:new(pane, #{width => #{gte => 120.0}}), ok.\nok\n2> tmux_filter:new(pane, F) =:= {ok, F}.\ntrue\n3> tmux_filter:new(pane, #{active => #{contains => <<\"yes\">>}}).\n{error,#{code => unsupported_operator,path => [active,contains],allowed => [equals,'not',in,not_in]}}"}]},"source":{"line":75,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-new-2"},{"id":"tmux_filter:new_or_error/2","publicId":"tmux_filter:new_or_error/2","qualifiedName":"tmux_filter:new_or_error/2","name":"new_or_error/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"new_or_error(Entity, Criteria)\n-spec new_or_error(tmux_schema:entity(), map() | t()) ->\n                      t().","references":[{"start":50,"end":68,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":72,"end":75,"target":"t:erlang:map/0"},{"start":80,"end":81,"target":"t:tmux_filter:t/0"},{"start":110,"end":111,"target":"t:tmux_filter:t/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Criteria","type":"map() | t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":9,"target":"t:tmux_filter:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a normalized portable filter, raising bad_filter on malformed trusted criteria. Performs no tmux I/O. External input should use `new/2` or `from_wire/2` for tagged validation errors."},"source":{"line":86,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-new_or_error-2"},{"id":"tmux_filter:predicate/1","publicId":"tmux_filter:predicate/1","qualifiedName":"tmux_filter:predicate/1","name":"predicate/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"predicate(Prepared)\n-spec predicate(prepared()) ->\n                   fun((tmux_model:row()) -> boolean()).","references":[{"start":36,"end":44,"target":"t:tmux_filter:prepared/0"},{"start":75,"end":89,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":96,"end":103,"target":"t:erlang:boolean/0"}],"params":[{"name":"Prepared","type":"prepared()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_filter:prepared/0"}]}],"returns":"fun((tmux_model:row()) -> boolean())","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":26,"end":33,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a Boolean function bound to the prepared observation context.","body":"Rows outside that context raise {prepared_context_mismatch, Detail}. Regex\nevaluation errors raise {filter_evaluation_failed, Detail}. Use `matches/2`\nfor tagged errors. This does not run callbacks."},"source":{"line":205,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-predicate-1"},{"id":"tmux_filter:prepare/2","publicId":"tmux_filter:prepare/2","qualifiedName":"tmux_filter:prepare/2","name":"prepare/2","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"prepare/2\n-spec prepare(t(), tmux_snapshot:t()) ->\n                 {ok, prepared()} | {error, map()}.","references":[{"start":24,"end":25,"target":"t:tmux_filter:t/0"},{"start":29,"end":44,"target":"t:tmux_snapshot:t/0"},{"start":73,"end":81,"target":"t:tmux_filter:prepared/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":95,"end":98,"target":"t:erlang:map/0"}],"params":[{"name":"Filter","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]},{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, prepared()} | {error, map()}","returnsReferences":[{"start":5,"end":13,"target":"t:tmux_filter:prepared/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Bind a filter to one snapshot and check all required coverage first.","body":"The prepared value can match only unmodified rows captured in that snapshot.\nIt remains usable after the endpoint closes. It cannot refresh observations.","examples":[{"lang":"erlang","code":"1> {ok, F} = tmux_filter:new(pane, #{width => #{gte => 80}}), ok.\nok\n2> tmux_filter:requirements(F).\n[{collection,pane},{field,pane,width}]"}]},"source":{"line":178,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-prepare-2"},{"id":"tmux_filter:requirements/1","publicId":"tmux_filter:requirements/1","qualifiedName":"tmux_filter:requirements/1","name":"requirements/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"requirements/1\n-spec requirements(t()) -> [tmux_snapshot:requirement()].","references":[{"start":34,"end":35,"target":"t:tmux_filter:t/0"},{"start":43,"end":68,"target":"t:tmux_snapshot:requirement/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"[tmux_snapshot:requirement()]","returnsReferences":[{"start":1,"end":26,"target":"t:tmux_snapshot:requirement/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Derive every field and complete relationship needed for faithful evaluation. The complete requirement set is checked before short-circuiting any row."},"source":{"line":161,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-requirements-1"},{"id":"tmux_filter:to_wire/1","publicId":"tmux_filter:to_wire/1","qualifiedName":"tmux_filter:to_wire/1","name":"to_wire/1","namespace":"tmux_filter","parent":"tmux_filter","kind":"function","modifiers":[],"signatures":[{"raw":"to_wire/1\n-spec to_wire(t()) -> wire_document().","references":[{"start":24,"end":25,"target":"t:tmux_filter:t/0"},{"start":32,"end":45,"target":"t:tmux_filter:wire_document/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_filter:t/0"}]}],"returns":"wire_document()","returnsReferences":[{"start":0,"end":13,"target":"t:tmux_filter:wire_document/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Export versioned JSON-compatible predicate data with generated wire names. Byte operands use base64 objects and known absence uses JSON null. Functions, compiled regexes and native record internals never enter this representation."},"source":{"line":125,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_filter-to_wire-1"},{"id":"t:tmux_filter:expr/0","publicId":"t:tmux_filter:expr/0","qualifiedName":"tmux_filter:expr/0","name":"expr/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type expr() ::\n          {all | any, [expr()]} |\n          {negate, expr()} |\n          {field, binary(), atom(), term()} |\n          {relation, binary(), atom(), expr()} |\n          {count, binary(), [{atom(), term()}]}.","params":[],"references":[{"start":39,"end":43,"target":"t:tmux_filter:expr/0"},{"start":69,"end":73,"target":"t:tmux_filter:expr/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":97,"end":103,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":107,"end":111,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":115,"end":119,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":146,"end":152,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":156,"end":160,"target":"t:erlang:atom/0"},{"start":164,"end":168,"target":"t:tmux_filter:expr/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":192,"end":198,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":204,"end":208,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":212,"end":216,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Normalized data expressions with stable field IDs, used by internal planners; not the wire grammar."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_filter-expr-0"},{"id":"t:tmux_filter:prepared/0","publicId":"t:tmux_filter:prepared/0","qualifiedName":"tmux_filter:prepared/0","name":"prepared/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque prepared().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A cached evaluator bound to one captured observation and schema context."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_filter-prepared-0"},{"id":"t:tmux_filter:t/0","publicId":"t:tmux_filter:t/0","qualifiedName":"tmux_filter:t/0","name":"t/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Portable normalized predicate data for one schema entity; contains no executable state."},"source":{"line":40,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_filter-t-0"},{"id":"t:tmux_filter:wire_document/0","publicId":"t:tmux_filter:wire_document/0","qualifiedName":"tmux_filter:wire_document/0","name":"wire_document/0","namespace":"tmux_filter","parent":"tmux_filter","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type wire_document() :: #{binary() => json:encode_value()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:encode_value/0","project":"Erlang/OTP"},"start":39,"end":56,"target":"t:json:encode_value/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Version-one JSON-compatible filter envelope with binary keys version, entity and where. entity is the generated wire entity name; where contains Boolean, field and relationship conditions. Version is the integer 1. Keys and operators still require `from_wire/2` validation; the typespec alone does not authorize arbitrary fields or unbounded external input."},"source":{"line":57,"file":"apps/libtmux_erlang/src/tmux_filter.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_filter-wire_document-0"},{"id":"tmux_hook","publicId":"tmux_hook","qualifiedName":"tmux_hook","name":"tmux_hook","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Store builtin hook commands and run them in an explicit observed context.","body":"`set/3` replaces one indexed entry. `append/3` uses tmux's first vacant index;\n`clear/2` leaves an empty local array and `unset/2` restores inheritance.\n`get/3` reads local values unless inheritance is requested. Commands are\n`t:tmux_command:t/0` values, rendered by `tmux_command:to_config/1` before tmux\nparses and stores them. A successful write confirms registration, while later\nhook effects need their own completion evidence.\n\nTable scope and execution context are separate. `run/2` selects a session,\nchecked window link or checked pane/link pair. Physical windows can belong to\nseveral sessions; a link preserves the chosen session and index. Preflight and\ndispatch are separate observations, with no atomic compare-and-act guarantee.\nKnown restarts and closed owners invalidate references. Captured rows never\nrefresh during these actions.\n\nNames and table scopes use the exact source-derived version catalogue from\n`tmux_option:catalogue/1`. User options, prefixes and aliases are rejected.\nThe native custom-event and monitor interfaces are outside this API. Deliberate\nraw integration remains available through `tmux_command:raw/2`. Calls perform\nI/O after validation and never retry uncertain mutations. The\n[hook guide](hooks.md) demonstrates registration and an effect acknowledgement."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook"},{"id":"tmux_hook:append/3","publicId":"tmux_hook:append/3","qualifiedName":"tmux_hook:append/3","name":"append/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"append(Scope, Name0, Commands)\n-spec append(scope(), binary(), commands()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":44,"end":49,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":53,"end":59,"target":"t:erlang:binary/0"},{"start":63,"end":71,"target":"t:tmux_hook:commands/0"},{"start":99,"end":123,"target":"t:tmux_operation:completed/0"},{"start":153,"end":175,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Commands","type":"commands()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_hook:commands/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Store commands at tmux's first vacant local index for the unindexed name. A new local array starts independently of inherited entries; this does not copy the parent's array. The command result does not report the chosen index; `get/3` observes current entries separately. Performs I/O with the parsing and unknown-outcome semantics of `set/3`."},"source":{"line":116,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-append-3"},{"id":"tmux_hook:clear/2","publicId":"tmux_hook:clear/2","qualifiedName":"tmux_hook:clear/2","name":"clear/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"clear(Scope, Name0)\n-spec clear(scope(), binary()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":32,"end":37,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":74,"end":98,"target":"t:tmux_operation:completed/0"},{"start":127,"end":149,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Leave an empty local hook array, masking inherited entries. This differs from `unset/2`, which restores inheritance. Global clear empties that defaults table. Performs I/O; existing effects already queued by tmux are not cancelled."},"source":{"line":132,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-clear-2"},{"id":"tmux_hook:get/3","publicId":"tmux_hook:get/3","qualifiedName":"tmux_hook:get/3","name":"get/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"get(Scope, Key, Options)\n-spec get(scope(),\n          tmux_option:key(),\n          tmux_option:read_options()) ->\n             {ok, value()} | none | {error, map()}.","references":[{"start":35,"end":40,"target":"t:tmux_hook:scope/0"},{"start":54,"end":69,"target":"t:tmux_option:key/0"},{"start":83,"end":107,"target":"t:tmux_option:read_options/0"},{"start":132,"end":137,"target":"t:tmux_hook:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":158,"end":161,"target":"t:erlang:map/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"tmux_option:key()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_option:key/0"}]},{"name":"Options","type":"tmux_option:read_options()","typeReferences":[{"start":0,"end":24,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, value()} | none | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_hook:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a builtin hook array or indexed entry. Options follow `t:tmux_option:read_options/0`: local-only by default, inherit = true follows its parent tables. Missing local arrays or entries return none; an empty local array returns {ok, #{}} and masks inheritance.","body":"Values are tmux's command-list serialization, including its quoting and escape\nsequences. They are neither the original input text nor individual decoded\narguments. Reading does not execute them. Use `set/3` for validated command\nvalues and `unset/2` to restore inheritance. Performs I/O and preserves backend\nerrors; a vanished target is not an absent hook."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-get-3"},{"id":"tmux_hook:run/2","publicId":"tmux_hook:run/2","qualifiedName":"tmux_hook:run/2","name":"run/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"run(Context, Name0)\n-spec run(context(), binary()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":30,"end":37,"target":"t:tmux_hook:context/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":41,"end":47,"target":"t:erlang:binary/0"},{"start":72,"end":96,"target":"t:tmux_operation:completed/0"},{"start":123,"end":145,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Context","type":"context()","typeReferences":[{"start":0,"end":7,"target":"t:tmux_hook:context/0"}]},{"name":"Name0","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request native set-hook -R in the explicit `t:context/0`. tmux resolves the hook through that context's effective tables; global table flags do not select a separate execution scope. A session uses its current window and pane. A window link fixes the observed session/index and expected physical window; a pane context additionally checks that pane's observed parent.","body":"Performs I/O. The result is the native command outcome, not an acknowledgement\nof background work launched by its commands. A missing or empty effective hook\ncan succeed without effects. Wait on an application completion condition when\neffects matter. Existence and membership checks precede dispatch. If the\ntarget disappears after preflight, tmux can still fall back to another\ncontext. This is not atomic compare-and-act. Use fresh links after known\ntopology changes."},"source":{"line":173,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-run-2"},{"id":"tmux_hook:set/3","publicId":"tmux_hook:set/3","qualifiedName":"tmux_hook:set/3","name":"set/3","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Commands)\n-spec set(scope(),\n          {binary(), non_neg_integer()},\n          commands()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":36,"end":41,"target":"t:tmux_hook:scope/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":56,"end":62,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"start":96,"end":104,"target":"t:tmux_hook:commands/0"},{"start":129,"end":153,"target":"t:tmux_operation:completed/0"},{"start":180,"end":202,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"{binary(), non_neg_integer()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":11,"end":26,"target":"t:erlang:non_neg_integer/0"}]},{"name":"Commands","type":"commands()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_hook:commands/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Replace one {Name, Index} entry with validated command values. An explicit index is required; other entries remain. Indexes range from zero to 2147483647. The rendered command text is bounded before dispatch. Native commands still interpret their arguments and formats when the hook later runs. Use `append/3` for native vacant-index selection and `clear/2` to mask inherited hooks with an empty local array.","body":"Performs I/O. tmux parses commands before replacing an existing entry, but a\nfailed first write can already create an empty local override. Registration\nand later execution are separate; this call promises no transaction, rollback\nor completion of future effects."},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-set-3"},{"id":"tmux_hook:unset/2","publicId":"tmux_hook:unset/2","qualifiedName":"tmux_hook:unset/2","name":"unset/2","namespace":"tmux_hook","parent":"tmux_hook","kind":"function","modifiers":[],"signatures":[{"raw":"unset(Scope, Key)\n-spec unset(scope(), tmux_option:key()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":30,"end":35,"target":"t:tmux_hook:scope/0"},{"start":39,"end":54,"target":"t:tmux_option:key/0"},{"start":81,"end":105,"target":"t:tmux_operation:completed/0"},{"start":134,"end":156,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_hook:scope/0"}]},{"name":"Key","type":"tmux_option:key()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_option:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one indexed entry or the whole local array. Removing an entry leaves its local array, possibly empty. Removing the whole array restores inheritance; unsetting a global builtin resets its native default. Missing local values are a successful native no-op. Performs I/O; queued hook effects are unaffected."},"source":{"line":148,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_hook-unset-2"},{"id":"t:tmux_hook:commands/0","publicId":"t:tmux_hook:commands/0","qualifiedName":"tmux_hook:commands/0","name":"commands/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type commands() ::\n          tmux_command:t() | [tmux_command:t(), ...].","params":[],"references":[{"start":30,"end":44,"target":"t:tmux_command:t/0"},{"start":50,"end":64,"target":"t:tmux_command:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One validated command or a nonempty list; at most 256 commands and 32 KiB rendered text."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_hook-commands-0"},{"id":"t:tmux_hook:context/0","publicId":"t:tmux_hook:context/0","qualifiedName":"tmux_hook:context/0","name":"context/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type context() ::\n          tmux_model:session() |\n          tmux_model:window_link() |\n          {pane,\n           tmux_model:pane(),\n           tmux_model:window_link()}.","params":[],"references":[{"start":29,"end":47,"target":"t:tmux_model:session/0"},{"start":62,"end":84,"target":"t:tmux_model:window_link/0"},{"start":117,"end":132,"target":"t:tmux_model:pane/0"},{"start":147,"end":169,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A session's current context, one observed membership, or a pane in that membership."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_hook-context-0"},{"id":"t:tmux_hook:scope/0","publicId":"t:tmux_hook:scope/0","qualifiedName":"tmux_hook:scope/0","name":"scope/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope() ::\n          tmux_model:session() |\n          tmux_model:window() |\n          tmux_model:pane() |\n          {session_defaults | window_defaults,\n           tmux_server:t()}.","params":[],"references":[{"start":27,"end":45,"target":"t:tmux_model:session/0"},{"start":60,"end":77,"target":"t:tmux_model:window/0"},{"start":92,"end":107,"target":"t:tmux_model:pane/0"},{"start":170,"end":183,"target":"t:tmux_server:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A registered local table or explicit global session/window defaults; see `t:tmux_option:scope/0`."},"source":{"line":33,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_hook-scope-0"},{"id":"t:tmux_hook:value/0","publicId":"t:tmux_hook:value/0","qualifiedName":"tmux_hook:value/0","name":"value/0","namespace":"tmux_hook","parent":"tmux_hook","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value() ::\n          binary() | #{non_neg_integer() => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":61,"end":67,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical native command-list text, or a sparse map of indexes to that text."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_hook.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_hook-value-0"},{"id":"tmux_identity","publicId":"tmux_identity","qualifiedName":"tmux_identity","name":"tmux_identity","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Observe a Linux process incarnation using its PID, boot ID and start ticks.","body":"A successful check is an observation. It neither reserves a PID nor pins a\ntmux connection, and it never authorizes signalling a process. Endpoint owners\nin `m:tmux_server` compare the PID returned by the current connection as well.\nA server can still change between this check and a later one-shot command.\n\nUse `fingerprint/1` to compare captured incarnations across endpoint handles\nor persist that comparison in a plan. It performs no process observation;\nthe key grants neither liveness nor permission to act.","examples":[{"lang":"erlang","code":"1> Pid = list_to_integer(os:getpid()), ok.\nok\n2> {ok, Identity} = tmux_identity:observe(Pid), ok.\nok\n3> tmux_identity:check(Identity, Pid).\nok"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_identity"},{"id":"tmux_identity:check/2","publicId":"tmux_identity:check/2","qualifiedName":"tmux_identity:check/2","name":"check/2","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"check/2\n-spec check(t(), pos_integer()) -> ok | {error, map()}.","references":[{"start":20,"end":21,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":25,"end":36,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":56,"end":59,"target":"t:erlang:map/0"}],"params":[{"name":"Identity","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_identity:t/0"}]},{"name":"ObservedPid","type":"pos_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Re-observe the PID and compare its incarnation token. A successful result is a momentary observation, not ownership, permission to signal, or a same-connection guarantee."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_identity-check-2"},{"id":"tmux_identity:fingerprint/1","publicId":"tmux_identity:fingerprint/1","qualifiedName":"tmux_identity:fingerprint/1","name":"fingerprint/1","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"fingerprint/1\n-spec fingerprint(t()) ->\n                     {ok, fingerprint()} |\n                     {error, #{code := invalid_identity}}.","references":[{"start":32,"end":33,"target":"t:tmux_identity:t/0"},{"start":66,"end":77,"target":"t:tmux_identity:fingerprint/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_identity:t/0"}]}],"returns":"{ok, fingerprint()} |\n          {error, #{code := invalid_identity}}","returnsReferences":[{"start":5,"end":16,"target":"t:tmux_identity:fingerprint/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Derive a portable `t:fingerprint/0` from a captured identity without I/O.","body":"The key includes PID, boot ID and process-start ticks. Reconnecting to the same\nprocess preserves it; changing any component changes it. The encoding is\nversioned for persisted plans. Use `check/2` for a fresh process observation.\nMalformed identity terms return invalid_identity before hashing.","examples":[{"lang":"erlang","code":"1> {ok, I} = tmux_identity:observe(list_to_integer(os:getpid())), ok.\nok\n2> {ok, Key} = tmux_identity:fingerprint(I), ok.\nok\n3> byte_size(Key).\n73"}]},"source":{"line":59,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_identity-fingerprint-1"},{"id":"tmux_identity:observe/1","publicId":"tmux_identity:observe/1","qualifiedName":"tmux_identity:observe/1","name":"observe/1","namespace":"tmux_identity","parent":"tmux_identity","kind":"function","modifiers":[],"signatures":[{"raw":"observe/1\n-spec observe(pos_integer()) -> {ok, t()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":24,"end":35,"target":"t:erlang:pos_integer/0"},{"start":47,"end":48,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Pid","type":"pos_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_identity:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observe a Linux PID incarnation without signalling it. Returns a tagged error if the process cannot be identified; this performs local operating-system I/O."},"source":{"line":79,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_identity-observe-1"},{"id":"t:tmux_identity:fingerprint/0","publicId":"t:tmux_identity:fingerprint/0","qualifiedName":"tmux_identity:fingerprint/0","name":"fingerprint/0","namespace":"tmux_identity","parent":"tmux_identity","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type fingerprint() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":23,"end":29,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Versioned SHA-256 comparison key for a captured Linux process incarnation. The linux-v1 prefix identifies the canonical encoding, independent of Erlang term serialization. Keys compare identity observations, not endpoint ownership or current liveness. They are identifiers, not authentication tokens."},"source":{"line":38,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_identity-fingerprint-0"},{"id":"t:tmux_identity:t/0","publicId":"t:tmux_identity:t/0","qualifiedName":"tmux_identity:t/0","name":"t/0","namespace":"tmux_identity","parent":"tmux_identity","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observed Linux PID, boot identity and process-start token. It does not pin a connection."},"source":{"line":30,"file":"apps/libtmux_erlang/src/tmux_identity.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_identity-t-0"},{"id":"tmux_json","publicId":"tmux_json","qualifiedName":"tmux_json","name":"tmux_json","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Decode bounded JSON using OTP's `m:json` parser and binary object keys.","body":"Documents are limited to 256 KiB before parsing and 32 nested containers\nduring parsing. Duplicate keys are rejected before overwriting values, even\nwhen different escapes spell the same key. Trailing input is rejected. Numbers\nstay in the shared exact integer range. Integral decimal tokens are converted\nexactly; fractional tokens that round to integers are rejected. Field\nvalidation decides whether a remaining float is permitted. Syntax and resource\nerrors have a root path; duplicate-key errors retain their complete document\npath. Use `tmux_filter:from_wire/2` to validate decoded filter data."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_json.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_json"},{"id":"tmux_json:decode/1","publicId":"tmux_json:decode/1","qualifiedName":"tmux_json:decode/1","name":"decode/1","namespace":"tmux_json","parent":"tmux_json","kind":"function","modifiers":[],"signatures":[{"raw":"decode/1\n-spec decode(binary()) ->\n                {ok, json:decode_value()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":22,"end":28,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":56,"end":73,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":87,"end":90,"target":"t:erlang:map/0"}],"params":[{"name":"Binary","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, json:decode_value()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/stdlib/json.html#t:decode_value/0","project":"Erlang/OTP"},"start":5,"end":22,"target":"t:json:decode_value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a decoded value or a structured error without creating payload atoms.","examples":[{"lang":"erlang","code":"1> tmux_json:decode(<<\"{\\\"a\\\": [1, true, null]}\">>).\n{ok,#{<<\"a\">> => [1,true,null]}}\n2> tmux_json:decode(<<\"{\\\"a\\\": {\\\"x\\\": 1, \\\"x\\\": 2}}\">>).\n{error,#{code => duplicate_key,path => [<<\"a\">>,<<\"x\">>]}}\n3> tmux_json:decode(<<\"[] []\">>).\n{error,#{code => trailing_input,path => []}}"}]},"source":{"line":32,"file":"apps/libtmux_erlang/src/tmux_json.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_json-decode-1"},{"id":"tmux_key","publicId":"tmux_key","qualifiedName":"tmux_key","name":"tmux_key","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Register and remove bindings in explicit server key tables.","body":"`bind/3` uses the native prefix table; `bind/4` chooses a table, repeat flag\nand note. Command values use `tmux_command:to_config/1` for the stored parser\nboundary. Replacing a binding resets its commands, repeat flag and note.\nRegistration does not prove that a client later executed the binding.\n\nTables belong to the server. A session's key-table option selects its default\ntable through `m:tmux_option`; tmux's prefix and client table-switching rules\nstill apply. Registering a custom table does not select it for any client.\n`clear_table/2` requires an explicit name and can affect attached clients.\n\n`listing/2` returns native presentation bytes. Field padding, quoting, note\ncoverage and formatting vary by daemon release. It does not decode bindings\nor promise reusable configuration. Retain the original command values when\nan application needs to install the same binding again.\n\nKey names use tmux's own binary spellings, such as C-b, Enter and MouseDown1Pane.\nThe daemon validates actual names and modifiers. Library validation bounds\nbytes and rejects NUL before dispatch. Calls use registered endpoint identity,\nperform explicit I/O and never retry uncertain mutations. They do not attach\na client or refresh captured rows.\n\nThe [key-table guide](keys.md) installs and removes an application-owned table."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key"},{"id":"tmux_key:bind/3","publicId":"tmux_key:bind/3","qualifiedName":"tmux_key:bind/3","name":"bind/3","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Key, Commands)\n-spec bind(tmux_server:t(),\n           key(),\n           tmux_command:t() | [tmux_command:t(), ...]) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":39,"end":52,"target":"t:tmux_server:t/0"},{"start":67,"end":70,"target":"t:tmux_key:key/0"},{"start":85,"end":99,"target":"t:tmux_command:t/0"},{"start":105,"end":119,"target":"t:tmux_command:t/0"},{"start":151,"end":175,"target":"t:tmux_operation:completed/0"},{"start":203,"end":225,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Commands","type":"tmux_command:t() | [tmux_command:t(), ...]","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"},{"start":20,"end":34,"target":"t:tmux_command:t/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Register commands in the native prefix table with default options. Performs I/O; see `bind/4` for replacement, command parsing and future execution."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-bind-3"},{"id":"tmux_key:bind/4","publicId":"tmux_key:bind/4","qualifiedName":"tmux_key:bind/4","name":"bind/4","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Key0, Commands, Options)\n-spec bind(tmux_server:t(),\n           key(),\n           tmux_command:t() | [tmux_command:t(), ...],\n           bind_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":49,"end":62,"target":"t:tmux_server:t/0"},{"start":77,"end":80,"target":"t:tmux_key:key/0"},{"start":95,"end":109,"target":"t:tmux_command:t/0"},{"start":115,"end":129,"target":"t:tmux_command:t/0"},{"start":150,"end":162,"target":"t:tmux_key:bind_options/0"},{"start":188,"end":212,"target":"t:tmux_operation:completed/0"},{"start":240,"end":262,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key0","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Commands","type":"tmux_command:t() | [tmux_command:t(), ...]","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"},{"start":20,"end":34,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"bind_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_key:bind_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Register or replace one binding with validated command values. Commands can be one value or a flat nonempty list; `tmux_command:to_config/1` applies the aggregate count and byte bounds. Options follow `t:bind_options/0`. Arguments, table names and notes are literal bytes at registration; stored commands still interpret their values and formats when a client executes them.","body":"Performs I/O. tmux parses the commands before replacing an existing binding.\nThe result confirms registration, while effects of future key presses need\ntheir own acknowledgement. Replacement resets the old repeat flag and note\nusing the supplied options. Errors preserve backend diagnostics and unknown\noutcomes; there is no rollback or automatic retry."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-bind-4"},{"id":"tmux_key:clear_table/2","publicId":"tmux_key:clear_table/2","qualifiedName":"tmux_key:clear_table/2","name":"clear_table/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"clear_table(Server, Table)\n-spec clear_table(tmux_server:t(), binary()) ->\n                     {ok, tmux_operation:completed()} |\n                     {error, tmux_operation:failure()}.","references":[{"start":45,"end":58,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":62,"end":68,"target":"t:erlang:binary/0"},{"start":101,"end":125,"target":"t:tmux_operation:completed/0"},{"start":160,"end":182,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Table","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove the entire explicitly named table through native unbind-key -a -T. Names use the bounds in `t:bind_options/0`. This can remove default bindings and affect attached clients. Missing tables remain native errors; this call does not restore factory defaults or cancel commands already queued. Performs I/O after endpoint and argument validation."},"source":{"line":114,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-clear_table-2"},{"id":"tmux_key:listing/1","publicId":"tmux_key:listing/1","qualifiedName":"tmux_key:listing/1","name":"listing/1","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"listing(Server)\n-spec listing(tmux_server:t()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":30,"end":43,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":72,"end":78,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read all tables as native listing bytes. Performs I/O; see `listing/2`."},"source":{"line":122,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-listing-1"},{"id":"tmux_key:listing/2","publicId":"tmux_key:listing/2","qualifiedName":"tmux_key:listing/2","name":"listing/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"listing/2\n-spec listing(tmux_server:t(), listing_options()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":24,"end":37,"target":"t:tmux_server:t/0"},{"start":41,"end":56,"target":"t:tmux_key:listing_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":85,"end":91,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":105,"end":108,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"listing_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_key:listing_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read native list-keys presentation output, optionally filtering by table and key through `t:listing_options/0`. Returns the command's stdout unchanged; spacing, quoting and included metadata follow that daemon. This is a text view, with no decoded-row, exact-note or configuration-round-trip guarantee.","body":"tmux 3.4 can escape dollar signs in this output. tmux 3.7c can send a single\nmatching entry to its status-message path, producing empty stdout without an\nattached target client. Empty presentation output does not prove absence.\nThe [key-table guide](keys.md) demonstrates a table with multiple bindings.\n\nThe baseline command has no custom format option on tmux 3.3. Deliberate\nnewer-server formatting is available through `tmux_command:raw/2`. Performs\nI/O; missing tables, invalid key spellings and backend errors remain errors."},"source":{"line":140,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-listing-2"},{"id":"tmux_key:unbind/2","publicId":"tmux_key:unbind/2","qualifiedName":"tmux_key:unbind/2","name":"unbind/2","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"unbind(Server, Key)\n-spec unbind(tmux_server:t(), key()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":33,"end":46,"target":"t:tmux_server:t/0"},{"start":50,"end":53,"target":"t:tmux_key:key/0"},{"start":81,"end":105,"target":"t:tmux_operation:completed/0"},{"start":135,"end":157,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove a binding from the native prefix table. Performs I/O; see `unbind/3`."},"source":{"line":83,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-unbind-2"},{"id":"tmux_key:unbind/3","publicId":"tmux_key:unbind/3","qualifiedName":"tmux_key:unbind/3","name":"unbind/3","namespace":"tmux_key","parent":"tmux_key","kind":"function","modifiers":[],"signatures":[{"raw":"unbind(Server, Key0, Options)\n-spec unbind(tmux_server:t(),\n             key(),\n             #{table => binary()}) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":43,"end":56,"target":"t:tmux_server:t/0"},{"start":73,"end":76,"target":"t:tmux_key:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":104,"end":110,"target":"t:erlang:binary/0"},{"start":139,"end":163,"target":"t:tmux_operation:completed/0"},{"start":193,"end":215,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Key0","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_key:key/0"}]},{"name":"Options","type":"#{table => binary()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":11,"end":17,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one key from the explicit table, defaulting to prefix. Only table is accepted in the options map. A missing key in an existing table is a native no-op; a missing explicit table remains an error. Removing the final custom binding can remove its table, so a repeated call can then report that missing table. Invalid native key names are never quietly suppressed.","body":"Performs I/O. Effects already queued by a client are unaffected. Use\n`clear_table/2` to remove an entire explicitly named table."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_key-unbind-3"},{"id":"t:tmux_key:bind_options/0","publicId":"t:tmux_key:bind_options/0","qualifiedName":"tmux_key:bind_options/0","name":"bind_options/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type bind_options() ::\n          #{table => binary(),\n            repeat => boolean(),\n            note => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":45,"end":51,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":77,"end":84,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":108,"end":114,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Default table is prefix and repeat is false. Tables contain 1..1024 NUL-free bytes. note is at most 32 KiB of NUL-free bytes; omitting it removes an old note when commands are replaced. Command-level aggregate bounds still apply."},"source":{"line":38,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_key-bind_options-0"},{"id":"t:tmux_key:key/0","publicId":"t:tmux_key:key/0","qualifiedName":"tmux_key:key/0","name":"key/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":15,"end":21,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A nonempty NUL-free native key spelling, at most 128 bytes; tmux validates its meaning."},"source":{"line":32,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_key-key-0"},{"id":"t:tmux_key:listing_options/0","publicId":"t:tmux_key:listing_options/0","qualifiedName":"tmux_key:listing_options/0","name":"listing_options/0","namespace":"tmux_key","parent":"tmux_key","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type listing_options() ::\n          #{table => binary(), key => key()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":48,"end":54,"target":"t:erlang:binary/0"},{"start":65,"end":68,"target":"t:tmux_key:key/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"No table filter lists all native tables. table restricts the listing to one nonempty NUL-free name of at most 1024 bytes; key restricts it to a native key spelling. Missing tables and invalid key spellings retain native errors. Unmatched filters can return empty output or a backend error by release."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_key.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_key-listing_options-0"},{"id":"tmux_matcher","publicId":"tmux_matcher","qualifiedName":"tmux_matcher","name":"tmux_matcher","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Prepare a trusted local predicate once for a captured snapshot.","body":"Use `tmux_select:matching/2` with `{Module, State}`. The application chooses\nModule; external filter documents cannot select the `c:prepare/2`\ncallback. Preparation returns a unary Boolean function or a tagged error.\nCallback exceptions propagate. The adapter does not make executable predicates\nportable or push them to tmux."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_matcher.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_matcher"},{"id":"c:tmux_matcher:prepare/2","publicId":"c:tmux_matcher:prepare/2","qualifiedName":"tmux_matcher:prepare/2","name":"prepare/2","namespace":"tmux_matcher","parent":"tmux_matcher","kind":"function","modifiers":["abstract"],"signatures":[{"raw":"-callback prepare(State :: term(),\n                  Snapshot :: tmux_snapshot:t()) ->\n                     {ok,\n                      fun((tmux_model:row()) ->\n                              boolean())} |\n                     {error, term()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":27,"end":31,"target":"t:erlang:term/0"},{"start":65,"end":80,"target":"t:tmux_snapshot:t/0"},{"start":140,"end":154,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":191,"end":198,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":234,"end":238,"target":"t:erlang:term/0"}],"params":[{"name":"State","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, fun((tmux_model:row()) -> boolean())} |\n          {error, term()}","returnsReferences":[{"start":10,"end":24,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":31,"end":38,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":63,"end":67,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Prepare a local Boolean predicate once for this captured snapshot. Return a tagged preparation error when the matcher cannot operate. Callback exceptions remain application failures; this does not make a matcher portable or suitable for untrusted module selection."},"source":{"line":17,"file":"apps/libtmux_erlang/src/tmux_matcher.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"c-tmux_matcher-prepare-2"},{"id":"tmux_model","publicId":"tmux_model","qualifiedName":"tmux_model","name":"tmux_model","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Validated native domain records. Constructors perform no tmux I/O.","body":"Missing optional observations remain not_loaded; required identity fields\nmust be supplied. Unavailable capabilities remain\nunavailable. Neither state means an empty relation or known absence.\nRows created by `new/2` and the entity constructors are detached.\nEntity constructors accept generated input-map types such as\n`t:pane_input/0`. Use `new/2` to validate dynamic maps; Dialyzer checks\nknown constructor shapes but does not replace runtime validation.\nUse `tmux_server:bind/2` to register a fresh observed row for actions;\nuse `m:tmux_snapshot` for captured graph relationships.\n\nObserved rows carry a private `t:observation/0` value. Actions compare it\nwith the row's origin, snapshot identity and target fields, rejecting\nmismatched observations before I/O. Valid-shaped binding mismatches return\nobservation_mismatch; detached and malformed rows keep their validation\nerrors. Retarget through\n`tmux_server:bind/2`; it reads current values. This protects ordinary API\nuse, not authority against trusted code in the Erlang VM.\n\nNative model version 2 adds this association. Discard version-1 rows and\nsnapshots on upgrade and freshly observe them. `to_map/1` extracts domain\nfields for explicit schema validation; maps carry no actionable origin."},"source":{"line":2,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model"},{"id":"tmux_model:entity/1","publicId":"tmux_model:entity/1","qualifiedName":"tmux_model:entity/1","name":"entity/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"entity/1\n-spec entity(row()) -> tmux_schema:entity().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"start":32,"end":50,"target":"t:tmux_schema:entity/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"tmux_schema:entity()","returnsReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the built-in entity kind of a native row without I/O."},"source":{"line":233,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-entity-1"},{"id":"tmux_model:get/2","publicId":"tmux_model:get/2","qualifiedName":"tmux_model:get/2","name":"get/2","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"get/2\n-spec get(atom(), row()) -> term().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":16,"end":20,"target":"t:erlang:atom/0"},{"start":24,"end":27,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":34,"end":38,"target":"t:erlang:term/0"}],"params":[{"name":"Argument1","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Argument2","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"term()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a permitted domain field without I/O. Unknown fields raise unknown_field; unloaded and unavailable values remain distinct."},"source":{"line":268,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-get-2"},{"id":"tmux_model:model_version/1","publicId":"tmux_model:model_version/1","qualifiedName":"tmux_model:model_version/1","name":"model_version/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"model_version/1\n-spec model_version(row()) -> pos_integer().","references":[{"start":36,"end":39,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":46,"end":57,"target":"t:erlang:pos_integer/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"pos_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":0,"end":11,"target":"t:erlang:pos_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the native model version. Unknown versions fail validation; record internals are not a persistence format."},"source":{"line":254,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-model_version-1"},{"id":"tmux_model:new/2","publicId":"tmux_model:new/2","qualifiedName":"tmux_model:new/2","name":"new/2","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"new(Entity, Fields)\n-spec new(atom(), map()) ->\n             {ok, row()} |\n             {error, tmux_schema:error_detail()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":30,"end":34,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"start":66,"end":69,"target":"t:tmux_model:row/0"},{"start":96,"end":120,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Fields","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"returns":"{ok, row()} | {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":8,"target":"t:tmux_model:row/0"},{"start":22,"end":46,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached row from validated observations.","body":"Accepts dynamic maps, including malformed input that returns a tagged\n`t:tmux_schema:error_detail/0`. For trusted typed code, prefer the entity\nconstructors such as `pane/1` and `t:pane_input/0`.","examples":[{"lang":"erlang","code":"1> {ok, Pane} = tmux_model:new(pane, #{id => <<\"%1\">>, width => 120}), ok.\nok\n2> tmux_model:get(width, Pane).\n120"}]},"source":{"line":192,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-new-2"},{"id":"tmux_model:origin/1","publicId":"tmux_model:origin/1","qualifiedName":"tmux_model:origin/1","name":"origin/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"origin/1\n-spec origin(row()) -> none | reference().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":39,"end":48,"target":"t:erlang:reference/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"none | reference()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":7,"end":16,"target":"t:erlang:reference/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the opaque origin token, or none for a detached row. This does not revalidate endpoint lifetime."},"source":{"line":240,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-origin-1"},{"id":"tmux_model:pane/1","publicId":"tmux_model:pane/1","qualifiedName":"tmux_model:pane/1","name":"pane/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"pane(Fields)\n-spec pane(pane_input()) ->\n              {ok, pane()} |\n              {error, tmux_schema:error_detail()}.","references":[{"start":24,"end":34,"target":"t:tmux_model:pane_input/0"},{"start":60,"end":64,"target":"t:tmux_model:pane/0"},{"start":92,"end":116,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"pane_input()","typeReferences":[{"start":0,"end":10,"target":"t:tmux_model:pane_input/0"}]}],"returns":"{ok, pane()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":9,"target":"t:tmux_model:pane/0"},{"start":33,"end":57,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached pane row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":212,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-pane-1"},{"id":"tmux_model:session/1","publicId":"tmux_model:session/1","qualifiedName":"tmux_model:session/1","name":"session/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"session(Fields)\n-spec session(session_input()) ->\n                 {ok, session()} |\n                 {error, tmux_schema:error_detail()}.","references":[{"start":30,"end":43,"target":"t:tmux_model:session_input/0"},{"start":72,"end":79,"target":"t:tmux_model:session/0"},{"start":110,"end":134,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"session_input()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_model:session_input/0"}]}],"returns":"{ok, session()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":12,"target":"t:tmux_model:session/0"},{"start":36,"end":60,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached session row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":200,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-session-1"},{"id":"tmux_model:snapshot_id/1","publicId":"tmux_model:snapshot_id/1","qualifiedName":"tmux_model:snapshot_id/1","name":"snapshot_id/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot_id/1\n-spec snapshot_id(row()) -> none | reference().","references":[{"start":32,"end":35,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":49,"end":58,"target":"t:erlang:reference/0"}],"params":[{"name":"Argument1","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"none | reference()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":7,"end":16,"target":"t:erlang:reference/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the capture identity, or none when not associated with a snapshot. Performs no I/O."},"source":{"line":247,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-snapshot_id-1"},{"id":"tmux_model:to_map/1","publicId":"tmux_model:to_map/1","qualifiedName":"tmux_model:to_map/1","name":"to_map/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"to_map/1\n-spec to_map(row()) -> map().","references":[{"start":22,"end":25,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"row()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_model:row/0"}]}],"returns":"map()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return domain field values without origin or capture metadata. This is not the portable filter wire representation. Performs no I/O."},"source":{"line":261,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-to_map-1"},{"id":"tmux_model:validate/1","publicId":"tmux_model:validate/1","qualifiedName":"tmux_model:validate/1","name":"validate/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"validate(Row)\n-spec validate(term()) -> {ok, row()} | {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":29,"end":33,"target":"t:erlang:term/0"},{"start":45,"end":48,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, row()} | {error, map()}","returnsReferences":[{"start":5,"end":8,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate native row shape, model version and normalized observations. Exported records do not enforce these invariants at construction. Performs no I/O."},"source":{"line":216,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-validate-1"},{"id":"tmux_model:window/1","publicId":"tmux_model:window/1","qualifiedName":"tmux_model:window/1","name":"window/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"window(Fields)\n-spec window(window_input()) ->\n                {ok, window()} |\n                {error, tmux_schema:error_detail()}.","references":[{"start":28,"end":40,"target":"t:tmux_model:window_input/0"},{"start":68,"end":74,"target":"t:tmux_model:window/0"},{"start":104,"end":128,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"window_input()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_model:window_input/0"}]}],"returns":"{ok, window()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":11,"target":"t:tmux_model:window/0"},{"start":35,"end":59,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached window row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":204,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-window-1"},{"id":"tmux_model:window_link/1","publicId":"tmux_model:window_link/1","qualifiedName":"tmux_model:window_link/1","name":"window_link/1","namespace":"tmux_model","parent":"tmux_model","kind":"function","modifiers":[],"signatures":[{"raw":"window_link(Fields)\n-spec window_link(window_link_input()) ->\n                     {ok, window_link()} |\n                     {error, tmux_schema:error_detail()}.","references":[{"start":38,"end":55,"target":"t:tmux_model:window_link_input/0"},{"start":88,"end":99,"target":"t:tmux_model:window_link/0"},{"start":134,"end":158,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Fields","type":"window_link_input()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window_link_input/0"}]}],"returns":"{ok, window_link()} |\n          {error, tmux_schema:error_detail()}","returnsReferences":[{"start":5,"end":16,"target":"t:tmux_model:window_link/0"},{"start":40,"end":64,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Construct a detached window_link row, validating required fields and scalar bounds without tmux I/O."},"source":{"line":208,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-window_link-1"},{"id":"t:tmux_model:observation/0","publicId":"t:tmux_model:observation/0","qualifiedName":"tmux_model:observation/0","name":"observation/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque observation().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Private captured target association, created by observation. Retain with its row; construction and field access are internal. It is not an authorization or serialization format."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-observation-0"},{"id":"t:tmux_model:pane/0","publicId":"t:tmux_model:pane/0","qualifiedName":"tmux_model:pane/0","name":"pane/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pane() :: #pane{}.","params":[],"references":[{"start":16,"end":21,"target":"#tmux_model:pane{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated pane observation. Native records are experimental in OTP 29."},"source":{"line":112,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-pane-0"},{"id":"t:tmux_model:pane_id/0","publicId":"t:tmux_model:pane_id/0","qualifiedName":"tmux_model:pane_id/0","name":"pane_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal pane_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":22,"end":28,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical pane ID binary in the percent namespace; nominal checking is by Dialyzer."},"source":{"line":37,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-pane_id-0"},{"id":"t:tmux_model:pane_input/0","publicId":"t:tmux_model:pane_input/0","qualifiedName":"tmux_model:pane_input/0","name":"pane_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pane_input() ::\n          #{id := pane_id(),\n            window_id =>\n                window_id() | not_loaded | unavailable,\n            index =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            active => boolean() | not_loaded | unavailable,\n            current_command =>\n                binary() | not_loaded | unavailable,\n            current_path =>\n                binary() | not_loaded | unavailable,\n            width =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            height =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            pid =>\n                pos_integer() |\n                float() |\n                none | not_loaded | unavailable,\n            title => binary() | not_loaded | unavailable,\n            dead => boolean() | not_loaded | unavailable,\n            exit_status =>\n                integer() |\n                float() |\n                none | not_loaded | unavailable}.","params":[],"references":[{"start":40,"end":47,"target":"t:tmux_model:pane_id/0"},{"start":92,"end":101,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":169,"end":184,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":205,"end":210,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":279,"end":286,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":364,"end":370,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":445,"end":451,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":519,"end":534,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":555,"end":560,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":645,"end":660,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":681,"end":686,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":768,"end":779,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":800,"end":805,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":880,"end":886,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":937,"end":944,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":1018,"end":1025,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":1046,"end":1051,"target":"t:erlang:float/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `pane/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":162,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-pane_input-0"},{"id":"t:tmux_model:row/0","publicId":"t:tmux_model:row/0","qualifiedName":"tmux_model:row/0","name":"row/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type row() ::\n          #session{} | #window{} | #window_link{} | #pane{}.","params":[],"references":[{"start":25,"end":33,"target":"#tmux_model:session{}"},{"start":38,"end":45,"target":"#tmux_model:window{}"},{"start":50,"end":62,"target":"#tmux_model:window_link{}"},{"start":67,"end":72,"target":"#tmux_model:pane{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One schema-defined native domain record, with separate origin and capture metadata."},"source":{"line":104,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-row-0"},{"id":"t:tmux_model:session/0","publicId":"t:tmux_model:session/0","qualifiedName":"tmux_model:session/0","name":"session/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type session() :: #session{}.","params":[],"references":[{"start":19,"end":27,"target":"#tmux_model:session{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated session observation. Native records are experimental in OTP 29."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-session-0"},{"id":"t:tmux_model:session_id/0","publicId":"t:tmux_model:session_id/0","qualifiedName":"tmux_model:session_id/0","name":"session_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal session_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":25,"end":31,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical session ID binary in the dollar namespace."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-session_id-0"},{"id":"t:tmux_model:session_input/0","publicId":"t:tmux_model:session_input/0","qualifiedName":"tmux_model:session_input/0","name":"session_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type session_input() ::\n          #{id := session_id(),\n            name => binary() | not_loaded | unavailable,\n            attached_count =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            attached =>\n                boolean() | not_loaded | unavailable,\n            created =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable}.","params":[],"references":[{"start":43,"end":53,"target":"t:tmux_model:session_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":77,"end":83,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":160,"end":175,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":196,"end":201,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":288,"end":295,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":365,"end":380,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":401,"end":406,"target":"t:erlang:float/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `session/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":120,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-session_input-0"},{"id":"t:tmux_model:window/0","publicId":"t:tmux_model:window/0","qualifiedName":"tmux_model:window/0","name":"window/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window() :: #window{}.","params":[],"references":[{"start":18,"end":25,"target":"#tmux_model:window{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated window observation. Native records are experimental in OTP 29."},"source":{"line":108,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-window-0"},{"id":"t:tmux_model:window_id/0","publicId":"t:tmux_model:window_id/0","qualifiedName":"tmux_model:window_id/0","name":"window_id/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-nominal window_id() :: binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":24,"end":30,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A canonical physical-window ID binary in the at-sign namespace."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-window_id-0"},{"id":"t:tmux_model:window_input/0","publicId":"t:tmux_model:window_input/0","qualifiedName":"tmux_model:window_input/0","name":"window_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_input() ::\n          #{id := window_id(),\n            name => binary() | not_loaded | unavailable,\n            width =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            height =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            pane_count =>\n                non_neg_integer() |\n                float() |\n                not_loaded | unavailable,\n            layout => binary() | not_loaded | unavailable}.","params":[],"references":[{"start":42,"end":51,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":149,"end":164,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":185,"end":190,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":275,"end":290,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":311,"end":316,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":405,"end":420,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":441,"end":446,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":515,"end":521,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `window/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":134,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-window_input-0"},{"id":"t:tmux_model:window_link/0","publicId":"t:tmux_model:window_link/0","qualifiedName":"tmux_model:window_link/0","name":"window_link/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_link() :: #window_link{}.","params":[],"references":[{"start":23,"end":35,"target":"#tmux_model:window_link{}"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated window_link observation. Native records are experimental in OTP 29."},"source":{"line":110,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-window_link-0"},{"id":"t:tmux_model:window_link_input/0","publicId":"t:tmux_model:window_link_input/0","qualifiedName":"tmux_model:window_link_input/0","name":"window_link_input/0","namespace":"tmux_model","parent":"tmux_model","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type window_link_input() ::\n          #{session_id := session_id(),\n            window_id := window_id(),\n            index := non_neg_integer() | float(),\n            active => boolean() | not_loaded | unavailable}.","params":[],"references":[{"start":55,"end":65,"target":"t:tmux_model:session_id/0"},{"start":94,"end":103,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":128,"end":143,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:float/0","project":"Erlang/OTP"},"start":148,"end":153,"target":"t:erlang:float/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":179,"end":186,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Trusted constructor fields for `window_link/1`. Required keys use :=; optional observations may be not_loaded or unavailable. Integral floats are normalized to integers. Runtime validation still checks ranges, IDs, UTF-8 and derived values. Use `new/2` for dynamically validated maps."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_model-window_link_input-0"},{"id":"#tmux_model:session{}","publicId":"#tmux_model:session{}","qualifiedName":"#tmux_model:session{}","name":"#session{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #session{id :: session_id(),\n                 name =\n                     not_loaded ::\n                         binary() |\n                         not_loaded | unavailable,\n                 attached_count =\n                     not_loaded ::\n                         non_neg_integer() |\n                         not_loaded | unavailable,\n                 attached =\n                     not_loaded ::\n                         boolean() |\n                         not_loaded | unavailable,\n                 created =\n                     not_loaded ::\n                         non_neg_integer() |\n                         not_loaded | unavailable,\n                 origin = none :: none | reference(),\n                 snapshot_id = none :: none | reference(),\n                 model_version = 2 :: pos_integer(),\n                 observation =\n                     none :: none | observation()}.","params":[],"references":[{"start":23,"end":33,"target":"t:tmux_model:session_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":121,"end":127,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":277,"end":292,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":436,"end":443,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":586,"end":601,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":698,"end":707,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":757,"end":766,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":808,"end":819,"target":"t:erlang:pos_integer/0"},{"start":890,"end":901,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-session"},{"id":"#tmux_model:window{}","publicId":"#tmux_model:window{}","qualifiedName":"#tmux_model:window{}","name":"#window{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #window{id :: window_id(),\n                name =\n                    not_loaded ::\n                        binary() | not_loaded | unavailable,\n                width =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                height =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                pane_count =\n                    not_loaded ::\n                        non_neg_integer() |\n                        not_loaded | unavailable,\n                layout =\n                    not_loaded ::\n                        binary() | not_loaded | unavailable,\n                origin = none :: none | reference(),\n                snapshot_id = none :: none | reference(),\n                model_version = 2 :: pos_integer(),\n                observation = none :: none | observation()}.","params":[],"references":[{"start":22,"end":31,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":116,"end":122,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":235,"end":250,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":388,"end":403,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":545,"end":560,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":698,"end":704,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":775,"end":784,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":833,"end":842,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":883,"end":894,"target":"t:erlang:pos_integer/0"},{"start":943,"end":954,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":60,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-window"},{"id":"#tmux_model:window_link{}","publicId":"#tmux_model:window_link{}","qualifiedName":"#tmux_model:window_link{}","name":"#window_link{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #window_link{session_id :: session_id(),\n                     window_id :: window_id(),\n                     index :: non_neg_integer(),\n                     active =\n                         not_loaded ::\n                             boolean() |\n                             not_loaded | unavailable,\n                     origin = none :: none | reference(),\n                     snapshot_id =\n                         none :: none | reference(),\n                     model_version = 2 :: pos_integer(),\n                     observation =\n                         none :: none | observation()}.","params":[],"references":[{"start":35,"end":45,"target":"t:tmux_model:session_id/0"},{"start":83,"end":92,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":126,"end":141,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":243,"end":250,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":355,"end":364,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":443,"end":452,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":498,"end":509,"target":"t:erlang:pos_integer/0"},{"start":588,"end":599,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-window_link"},{"id":"#tmux_model:pane{}","publicId":"#tmux_model:pane{}","qualifiedName":"#tmux_model:pane{}","name":"#pane{}","namespace":"tmux_model","parent":"tmux_model","kind":"struct","modifiers":[],"signatures":[{"raw":"-record #pane{id :: pane_id(),\n              window_id =\n                  not_loaded ::\n                      window_id() |\n                      not_loaded | unavailable,\n              index =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              active =\n                  not_loaded ::\n                      boolean() | not_loaded | unavailable,\n              current_command =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              current_path =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              width =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              height =\n                  not_loaded ::\n                      non_neg_integer() |\n                      not_loaded | unavailable,\n              pid =\n                  not_loaded ::\n                      pos_integer() |\n                      none | not_loaded | unavailable,\n              title =\n                  not_loaded ::\n                      binary() | not_loaded | unavailable,\n              dead =\n                  not_loaded ::\n                      boolean() | not_loaded | unavailable,\n              exit_status =\n                  not_loaded ::\n                      integer() |\n                      none | not_loaded | unavailable,\n              origin = none :: none | reference(),\n              snapshot_id = none :: none | reference(),\n              model_version = 2 :: pos_integer(),\n              observation = none :: none | observation()}.","params":[],"references":[{"start":20,"end":27,"target":"t:tmux_model:pane_id/0"},{"start":111,"end":120,"target":"t:tmux_model:window_id/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":249,"end":264,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":394,"end":401,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":518,"end":524,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":638,"end":644,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":751,"end":766,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":896,"end":911,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":1038,"end":1049,"target":"t:erlang:pos_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":1185,"end":1191,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":1297,"end":1304,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":1417,"end":1424,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":1522,"end":1531,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":1578,"end":1587,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pos_integer/0","project":"Erlang/OTP"},"start":1626,"end":1637,"target":"t:erlang:pos_integer/0"},{"start":1684,"end":1695,"target":"t:tmux_model:observation/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","source":{"line":84,"file":"apps/libtmux_erlang/src/tmux_model.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_model-pane"},{"id":"tmux_operation","publicId":"tmux_operation","qualifiedName":"tmux_operation","name":"tmux_operation","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Own a command independently of an individual wait.","body":"`start/3` submits a validated command through the endpoint's\nbounded admission. The initiating process owns it. `await/2`\ntiming out abandons only that wait; `cancel/1` or owner death\nretires the client and may leave an unknown tmux outcome. The endpoint\nacknowledges `transfer/2` after monitoring the new owner and\nbefore replying to the old owner. The new process does not perform a\nhandshake. Retired results expire after 60 seconds or earlier when the\nendpoint exceeds 64 retained results or 4 MiB of retained stdout/stderr\n(oldest evicted first). Closing the endpoint clears its operation results\nimmediately. Each operation accepts at most 16 concurrent waiters; excess\nwaits return too_many_waiters. `await_started/2` returns\nlifecycle status once the operation leaves queued; dispatch authorization does\nnot establish a tmux aftereffect.\n\nSee `t:completed/0` and `t:failure/0` for\ncommand outcomes and `t:state/0` for lifecycle status. The [job\nguide](jobs.md) shows the complete workflow. Bounded OTP Logger reports\ncorrelate outcomes by operation and endpoint generation; see\n[runtime diagnostics](diagnostics.md) for levels, fields and data boundaries."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation"},{"id":"tmux_operation:await/2","publicId":"tmux_operation:await/2","qualifiedName":"tmux_operation:await/2","name":"await/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"await(Operation, Timeout)\n-spec await(t(), timeout()) ->\n               {ok, completed()} | {error, failure()}.","references":[{"start":38,"end":39,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":43,"end":50,"target":"t:erlang:timeout/0"},{"start":77,"end":86,"target":"t:tmux_operation:completed/0"},{"start":100,"end":107,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Timeout","type":"timeout()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:timeout/0"}]}],"returns":"{ok, completed()} | {error, failure()}","returnsReferences":[{"start":5,"end":14,"target":"t:tmux_operation:completed/0"},{"start":28,"end":35,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Wait for a retained result for at most Timeout. An await_timeout removes only this waiter; the operation continues and its handle remains usable. Additional waiters do not become owners. Results preserve outcome and cleanup certainty."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-await-2"},{"id":"tmux_operation:await_started/2","publicId":"tmux_operation:await_started/2","qualifiedName":"tmux_operation:await_started/2","name":"await_started/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"await_started(Operation, Timeout)\n-spec await_started(t(), timeout()) ->\n                       {ok, state()} | {error, failure()}.","references":[{"start":54,"end":55,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":59,"end":66,"target":"t:erlang:timeout/0"},{"start":101,"end":106,"target":"t:tmux_operation:state/0"},{"start":120,"end":127,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Timeout","type":"timeout()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:timeout/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:timeout/0"}]}],"returns":"{ok, state()} | {error, failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_operation:state/0"},{"start":24,"end":31,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Wait until the operation leaves queued, returning its lifecycle state even if it has already failed or retired. Inspect outcome and cleanup; call `await/2` for final command data. Authorization is not proof of a tmux aftereffect. A timeout abandons this wait without cancelling the operation."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-await_started-2"},{"id":"tmux_operation:cancel/1","publicId":"tmux_operation:cancel/1","qualifiedName":"tmux_operation:cancel/1","name":"cancel/1","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"cancel(Operation)\n-spec cancel(t()) ->\n                {ok,\n                 cancelled_before_send | cancel_requested |\n                 already_completed} |\n                {error, map()}.","references":[{"start":31,"end":32,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":182,"end":185,"target":"t:erlang:map/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]}],"returns":"{ok,\n           cancelled_before_send | cancel_requested |\n           already_completed} |\n          {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":109,"end":112,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request cancellation using this handle. Any holder can cancel; only the owner can transfer ownership. Queued work can be cancelled before submission; possibly sent work retires its client and can retain an unknown tmux outcome. Use `await/2` for the result and cleanup proof. Never infer rollback or automatically retry a mutation from cancellation alone. already_completed means a response exists; it does not establish complete cleanup."},"source":{"line":117,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-cancel-1"},{"id":"tmux_operation:start/3","publicId":"tmux_operation:start/3","qualifiedName":"tmux_operation:start/3","name":"start/3","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"start(Server, Command, Options)\n-spec start(tmux_server:t(),\n            tmux_command:t(),\n            tmux_server:command_options()) ->\n               {ok, t()} | {error, failure()}.","references":[{"start":44,"end":57,"target":"t:tmux_server:t/0"},{"start":73,"end":87,"target":"t:tmux_command:t/0"},{"start":103,"end":130,"target":"t:tmux_server:command_options/0"},{"start":157,"end":158,"target":"t:tmux_operation:t/0"},{"start":172,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Command","type":"tmux_command:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"tmux_server:command_options()","typeReferences":[{"start":0,"end":27,"target":"t:tmux_server:command_options/0"}]}],"returns":"{ok, t()} | {error, failure()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_operation:t/0"},{"start":20,"end":27,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Submit a validated command under the endpoint's admission limits and return an operation handle. The initiating process owns it. Submission is non-blocking with respect to command completion; the handle does not prove that tmux has executed the command."},"source":{"line":77,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-start-3"},{"id":"tmux_operation:status/1","publicId":"tmux_operation:status/1","qualifiedName":"tmux_operation:status/1","name":"status/1","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"status(Operation)\n-spec status(t()) -> {ok, state()} | {error, failure()}.","references":[{"start":31,"end":32,"target":"t:tmux_operation:t/0"},{"start":44,"end":49,"target":"t:tmux_operation:state/0"},{"start":63,"end":70,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]}],"returns":"{ok, state()} | {error, failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_operation:state/0"},{"start":24,"end":31,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the retained lifecycle state without starting a tmux command. Expired handles return operation_expired. Status is observation of the operation, not evidence that a possibly sent mutation was cancelled."},"source":{"line":106,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-status-1"},{"id":"tmux_operation:transfer/2","publicId":"tmux_operation:transfer/2","qualifiedName":"tmux_operation:transfer/2","name":"transfer/2","namespace":"tmux_operation","parent":"tmux_operation","kind":"function","modifiers":[],"signatures":[{"raw":"transfer/2\n-spec transfer(t(), pid()) -> ok | {error, map()}.","references":[{"start":26,"end":27,"target":"t:tmux_operation:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":54,"end":57,"target":"t:erlang:map/0"}],"params":[{"name":"Operation","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_operation:t/0"}]},{"name":"Owner","type":"pid()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:pid/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Transfer ownership to a live process on this Erlang node. The endpoint installs its new owner monitor before releasing the previous monitor and returns after the swap. The new process performs no handshake. Waiters and ownership remain separate; endpoint ownership does not change.","body":"An `await_timeout` abandons the reply, not the queued ownership change. The\ntransfer may complete later. Use `status/1` to read the current owner before\nrelying on ownership; a timeout does not prove that the old owner remains."},"source":{"line":130,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_operation-transfer-2"},{"id":"t:tmux_operation:cleanup/0","publicId":"t:tmux_operation:cleanup/0","qualifiedName":"tmux_operation:cleanup/0","name":"cleanup/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type cleanup() :: complete | incomplete | unverified.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"complete proves owned client retirement; incomplete or unverified does not."},"source":{"line":36,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-cleanup-0"},{"id":"t:tmux_operation:completed/0","publicId":"t:tmux_operation:completed/0","qualifiedName":"tmux_operation:completed/0","name":"completed/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type completed() ::\n          #{stdout := binary(),\n            stderr := binary(),\n            exit_status := 0,\n            stdin_delivered := non_neg_integer(),\n            outcome := success,\n            cleanup := complete}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":146,"end":161,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A successful command result. stdout and stderr are separate byte strings; exit_status is zero. stdin_delivered counts bytes accepted by the client pipe, not bytes consumed by tmux. success does not prove a background aftereffect."},"source":{"line":42,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-completed-0"},{"id":"t:tmux_operation:failure/0","publicId":"t:tmux_operation:failure/0","qualifiedName":"tmux_operation:failure/0","name":"failure/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type failure() ::\n          #{code := atom(),\n            outcome => outcome(),\n            cleanup => cleanup(),\n            stdout => binary(),\n            stderr => binary(),\n            stdin_delivered => non_neg_integer(),\n            exit_status => integer(),\n            submitted => boolean(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":39,"end":43,"target":"t:erlang:atom/0"},{"start":70,"end":77,"target":"t:tmux_operation:outcome/0"},{"start":104,"end":111,"target":"t:tmux_operation:cleanup/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":137,"end":143,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":169,"end":175,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":210,"end":225,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":256,"end":263,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":292,"end":299,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":315,"end":319,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":325,"end":329,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A tagged error detail with a stable code and optional certainty/output data. Validation, admission and wait errors may contain only code. Command failures retain available stdout/stderr, stdin_delivered and exit_status. Other keys provide code-specific context. Never infer missing certainty fields.","body":"Common codes are busy, invalid_operation_options, command_error, deadline,\ncancelled, stale_server, cleanup_incomplete, await_timeout and\noperation_expired. command_error means a nonzero client exit; it does not roll\nback a mutation. await_timeout abandons only this wait. operation_expired\ncannot reconstruct a previous result or establish its remote outcome."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-failure-0"},{"id":"t:tmux_operation:outcome/0","publicId":"t:tmux_operation:outcome/0","qualifiedName":"tmux_operation:outcome/0","name":"outcome/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type outcome() ::\n          success | error | not_started |\n          cancelled_before_send | unknown.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Command certainty, separate from resource cleanup. unknown must not trigger an automatic mutation retry."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-outcome-0"},{"id":"t:tmux_operation:state/0","publicId":"t:tmux_operation:state/0","qualifiedName":"tmux_operation:state/0","name":"state/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := queued | sent | responded | retired,\n            stage :=\n                pending | waiting | preflight | command,\n            owner := pid(),\n            outcome := pending | outcome(),\n            cleanup := pending | cleanup()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":174,"end":177,"target":"t:erlang:pid/0"},{"start":214,"end":221,"target":"t:tmux_operation:outcome/0"},{"start":258,"end":265,"target":"t:tmux_operation:cleanup/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Observed lifecycle state, without command output. queued includes admission and identity preflight; sent means dispatch authorization, not a proven aftereffect. responded can retain incomplete cleanup; retired releases operation resources. pending certainty means no result yet. The owner is the initiating or transferred process; holding a waiter handle does not change it."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-state-0"},{"id":"t:tmux_operation:t/0","publicId":"t:tmux_operation:t/0","qualifiedName":"tmux_operation:t/0","name":"t/0","namespace":"tmux_operation","parent":"tmux_operation","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A generation-bound operation handle. Possessing a waiter handle does not transfer ownership."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_operation.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_operation-t-0"},{"id":"tmux_option","publicId":"tmux_option","qualifiedName":"tmux_option","name":"tmux_option","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Read and change explicit tmux option tables through registered references.","body":"Session, physical window and pane records from `m:tmux_model` select their\nlocal tables. Global tables use {server, Server}, {session_defaults, Server}\nor {window_defaults, Server}. Built-in canonical names and scopes are checked\nagainst pinned source metadata; tmux otherwise lets a name override the\nsupplied scope flags. `m:tmux_hook` owns hook registration and execution;\nhooks are rejected here. Prefixes and aliases are rejected.\n\n`get/3` requires an explicit options map. Local-only reads are the\ndefault; inherit = true follows tmux's table parents (pane -> window -> window\ndefaults, or session -> session defaults). Server options have no parent. A\nmissing local value or array entry returns none; an empty binary or empty\narray is a value. Arrays return maps of indexes to binary values, preserving\nsparse indexes. There is no hidden capture refresh or cache of option values.\n`get_many/3` reads the same scalar key from up to seven local rows through one\nbounded native sequence, retaining local-only semantics by default.\n\nValues are NUL-free binary tmux text bytes, including non-UTF-8 bytes. No\nshell or format expansion is applied by this API. tmux still interprets a\nbuilt-in option according to its type: formats, shell commands and command\noptions may execute later when tmux uses them. This API is for trusted\napplication code. Numeric and flag values are canonical binary text on reads,\nnot Erlang numbers.\n\nBuilt-in metadata covers every released version in the supported tmux\n3.3a–3.8 range, including exact patch letters. Tracking and unknown versions\nfail closed. User options beginning @ do not need a built-in\ncatalogue. The raw `tmux_command:raw/2` remains available for deliberate\nnewer-server integration. All mutations are one-shot I/O with observed\nidentity checks, not transactions. Timeouts can leave an unknown remote\noutcome; mutations are never retried here. See the [scoped options\nguide](options.md) for ownership and inheritance."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option"},{"id":"tmux_option:catalogue/1","publicId":"tmux_option:catalogue/1","qualifiedName":"tmux_option:catalogue/1","name":"catalogue/1","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"catalogue(Version)\n-spec catalogue(tmux_version:t()) ->\n                   {ok, #{binary() => metadata()}} |\n                   {error, map()}.","references":[{"start":35,"end":49,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":82,"end":88,"target":"t:erlang:binary/0"},{"start":94,"end":102,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":136,"end":139,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]}],"returns":"{ok, #{binary() => metadata()}} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":7,"end":13,"target":"t:erlang:binary/0"},{"start":19,"end":27,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":42,"end":45,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return all canonical built-in option and hook metadata for one exact parsed version, without I/O. Catalogues cover every release from 3.3a through 3.8; historical 3.3 metadata remains available for source discovery. The generated reference records each release's source commit and file digests."},"source":{"line":89,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-catalogue-1"},{"id":"tmux_option:describe/2","publicId":"tmux_option:describe/2","qualifiedName":"tmux_option:describe/2","name":"describe/2","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"describe(Version, Name)\n-spec describe(tmux_version:t(), binary()) ->\n                  {ok, metadata()} | {error, map()}.","references":[{"start":39,"end":53,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":57,"end":63,"target":"t:erlang:binary/0"},{"start":93,"end":101,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":115,"end":118,"target":"t:erlang:map/0"}],"params":[{"name":"Version","type":"tmux_version:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_version:t/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, metadata()} | {error, map()}","returnsReferences":[{"start":5,"end":13,"target":"t:tmux_option:metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":27,"end":30,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return source metadata for a canonical built-in name and a parsed daemon version, without I/O. Unknown names, unavailable names, tracking builds and uncatalogued versions have distinct errors. The catalogue describes scopes and parser types; it does not qualify runtime behavior or authorize hook execution.","examples":[{"lang":"erlang","code":"1> {ok, V} = tmux_version:parse(<<\"tmux 3.3a\">>), ok.\nok\n2> {ok, M} = tmux_option:describe(V, <<\"exit-empty\">>), ok.\nok\n3> maps:get(scopes, M).\n[server]"}]},"source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-describe-2"},{"id":"tmux_option:get/3","publicId":"tmux_option:get/3","qualifiedName":"tmux_option:get/3","name":"get/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"get(Scope, Key, Options)\n-spec get(scope(), key(), read_options()) ->\n             {ok, value()} | none | {error, map()}.","references":[{"start":35,"end":40,"target":"t:tmux_option:scope/0"},{"start":44,"end":47,"target":"t:tmux_option:key/0"},{"start":51,"end":63,"target":"t:tmux_option:read_options/0"},{"start":88,"end":93,"target":"t:tmux_option:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":114,"end":117,"target":"t:erlang:map/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, value()} | none | {error, map()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_option:value/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":31,"end":34,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read one option or array, performing I/O after validation. Missing local values and array entries return none; known empty strings and arrays return {ok, Value}. inherit = true reads through tmux's parent tables. Unknown fields are rejected. Errors retain backend diagnostics; a missing target never becomes absence. Use `set/4` to write a value and `unset/2` to restore inheritance."},"source":{"line":105,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-get-3"},{"id":"tmux_option:get_many/3","publicId":"tmux_option:get_many/3","qualifiedName":"tmux_option:get_many/3","name":"get_many/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"get_many(Scopes, Name, Options)\n-spec get_many([tmux_model:session() |\n                tmux_model:window() |\n                tmux_model:pane(),\n                ...],\n               binary(),\n               read_options()) ->\n                  {ok, [binary() | none]} | {error, map()}.","references":[{"start":48,"end":66,"target":"t:tmux_model:session/0"},{"start":87,"end":104,"target":"t:tmux_model:window/0"},{"start":125,"end":140,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":181,"end":187,"target":"t:erlang:binary/0"},{"start":206,"end":218,"target":"t:tmux_option:read_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":249,"end":255,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":277,"end":280,"target":"t:erlang:map/0"}],"params":[{"name":"Scopes","type":"[tmux_model:session() |\n           tmux_model:window() |\n           tmux_model:pane(),\n           ...]","typeReferences":[{"start":1,"end":19,"target":"t:tmux_model:session/0"},{"start":35,"end":52,"target":"t:tmux_model:window/0"},{"start":68,"end":83,"target":"t:tmux_model:pane/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"read_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_option:read_options/0"}]}],"returns":"{ok, [binary() | none]} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":6,"end":12,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read one scalar option from one to seven local rows on the same registered endpoint. Performs one bounded native sequence after validating every scope. Results follow input order; each entry is binary text or none for a missing local value. `t:read_options/0` controls inheritance as in `get/3`.","body":"Names use ASCII letters, digits, dots, underscores and hyphens, with an\noptional leading @ for user options. Global tables, arrays, indexed keys,\nhooks and command options are unsupported. Use `get/3` for broader option\nreads and `tmux_hook:get/3` for hooks.\nInvalid scopes, unsupported keys and different owners fail before dispatch.\n\nEach read is bracketed by matching native target-ID observations. Unresolved\nor mismatched IDs reject the batch. The checks do not prove topology membership\nor completed destruction: older tmux may retain an unlinked pane through\nqueued references. The sequence provides interval observations and the same\nserver-incarnation guarantee as `get/3`. Ambient command configuration applies\nto both paths.\n\nStdout is bounded to 1 MiB and stderr to 64 KiB for the whole sequence, with\nthe endpoint's 2500 ms command deadline. Seven 32 KiB values fit even under\nthe qualified worst-case native quoting expansion. Larger external values\nmay exceed that aggregate output bound. Any command, framing or decoding\nfailure rejects the entire result, retaining native outcome and cleanup\nevidence. There is no partial-success result, hidden refresh or value cache."},"source":{"line":145,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-get_many-3"},{"id":"tmux_option:set/3","publicId":"tmux_option:set/3","qualifiedName":"tmux_option:set/3","name":"set/3","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Value)\n-spec set(scope(), key(), binary()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":33,"end":38,"target":"t:tmux_option:scope/0"},{"start":42,"end":45,"target":"t:tmux_option:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":49,"end":55,"target":"t:erlang:binary/0"},{"start":80,"end":104,"target":"t:tmux_operation:completed/0"},{"start":131,"end":153,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set one scalar or indexed array entry with default write options. Performs I/O; see `set/4` for append, only-if-unset, parsing and unknown-outcome semantics."},"source":{"line":164,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-set-3"},{"id":"tmux_option:set/4","publicId":"tmux_option:set/4","qualifiedName":"tmux_option:set/4","name":"set/4","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"set(Scope, Key, Value, Options)\n-spec set(scope(), key(), binary(), write_options()) ->\n             {ok, tmux_operation:completed()} |\n             {error, tmux_operation:failure()}.","references":[{"start":42,"end":47,"target":"t:tmux_option:scope/0"},{"start":51,"end":54,"target":"t:tmux_option:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":58,"end":64,"target":"t:erlang:binary/0"},{"start":68,"end":81,"target":"t:tmux_option:write_options/0"},{"start":106,"end":130,"target":"t:tmux_operation:completed/0"},{"start":157,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]},{"name":"Value","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"write_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_option:write_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set a literal binary value, after scope/version/owner validation. Array writes require {Name, Index}; this avoids tmux's whole-array separator grammar. append uses tmux's type-specific -a semantics. only_if_unset checks the local table; already-set is a backend error, with no suppressed errors or compare-and-swap guarantee. Values must be supplied explicitly; an empty flag value retains tmux's native toggle behavior. A successful result proves command completion, not later effects of a stored command or format. Performs I/O; never retries."},"source":{"line":178,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-set-4"},{"id":"tmux_option:unset/2","publicId":"tmux_option:unset/2","qualifiedName":"tmux_option:unset/2","name":"unset/2","namespace":"tmux_option","parent":"tmux_option","kind":"function","modifiers":[],"signatures":[{"raw":"unset(Scope, Key)\n-spec unset(scope(), key()) ->\n               {ok, tmux_operation:completed()} |\n               {error, tmux_operation:failure()}.","references":[{"start":30,"end":35,"target":"t:tmux_option:scope/0"},{"start":39,"end":42,"target":"t:tmux_option:key/0"},{"start":69,"end":93,"target":"t:tmux_operation:completed/0"},{"start":122,"end":144,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Scope","type":"scope()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_option:scope/0"}]},{"name":"Key","type":"key()","typeReferences":[{"start":0,"end":3,"target":"t:tmux_option:key/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove a local option or one indexed entry. Removing a local option restores inheritance; removing an entry leaves a local array, possibly empty. Unsetting a global built-in resets tmux's default; user options are removed. Missing local values are a successful tmux no-op. No pane-wide -U action is implied. Performs I/O and returns the command result without refreshing captured rows."},"source":{"line":198,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_option-unset-2"},{"id":"t:tmux_option:key/0","publicId":"t:tmux_option:key/0","qualifiedName":"tmux_option:key/0","name":"key/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() :: binary() | {binary(), non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":15,"end":21,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":37,"end":52,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical binary name; arrays use a structured non-negative index, never bracket syntax."},"source":{"line":44,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-key-0"},{"id":"t:tmux_option:metadata/0","publicId":"t:tmux_option:metadata/0","qualifiedName":"tmux_option:metadata/0","name":"metadata/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type metadata() ::\n          #{scopes := [server | session | window | pane],\n            type :=\n                choice | colour | command | flag | key |\n                number | string,\n            array := boolean(),\n            hook := boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":209,"end":216,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":240,"end":247,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-derived scope, parser type, array and executable-hook metadata."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-metadata-0"},{"id":"t:tmux_option:read_options/0","publicId":"t:tmux_option:read_options/0","qualifiedName":"tmux_option:read_options/0","name":"read_options/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type read_options() :: #{inherit => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":37,"end":44,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Local-only unless inherit is true. Unknown options and non-Booleans are errors."},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-read_options-0"},{"id":"t:tmux_option:scope/0","publicId":"t:tmux_option:scope/0","qualifiedName":"tmux_option:scope/0","name":"scope/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope() ::\n          tmux_model:session() |\n          tmux_model:window() |\n          tmux_model:pane() |\n          {server | session_defaults | window_defaults,\n           tmux_server:t()}.","params":[],"references":[{"start":27,"end":45,"target":"t:tmux_model:session/0"},{"start":60,"end":77,"target":"t:tmux_model:window/0"},{"start":92,"end":107,"target":"t:tmux_model:pane/0"},{"start":179,"end":192,"target":"t:tmux_server:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A registered local entity or an explicitly selected global option table."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-scope-0"},{"id":"t:tmux_option:value/0","publicId":"t:tmux_option:value/0","qualifiedName":"tmux_option:value/0","name":"value/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value() ::\n          binary() | #{non_neg_integer() => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":61,"end":67,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Canonical tmux text bytes for a scalar/entry, or a sparse map for a whole array."},"source":{"line":54,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-value-0"},{"id":"t:tmux_option:write_options/0","publicId":"t:tmux_option:write_options/0","qualifiedName":"tmux_option:write_options/0","name":"write_options/0","namespace":"tmux_option","parent":"tmux_option","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type write_options() ::\n          #{append => boolean(),\n            only_if_unset => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":47,"end":54,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":87,"end":94,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"append maps to -a; only_if_unset maps to -o and reports already-set errors. Both default false."},"source":{"line":52,"file":"apps/libtmux_erlang/src/tmux_option.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_option-write_options-0"},{"id":"tmux_pane","publicId":"tmux_pane","qualifiedName":"tmux_pane","name":"tmux_pane","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create, observe and rearrange panes using registered physical IDs.","body":"`split/2` accepts a pane or a window; a window means its active pane\nat execution. Options (`t:split_options/0`) are direction\n(horizontal or vertical), size ({cells, N} or {percent, N}), before,\nfull_size, zoom, cwd, env, launch and detach. It defaults to a detached\nvertical split. `get/2` returns newly observed fields; existing rows\nremain unchanged. Reads span several commands and do not claim atomicity.\nLaunch and environment options follow `tmux_session:create/2`. An absent or\nzero tmux pane_pid is represented as none. A captured positive PID is an\nobservation, not a guarantee that the process remains alive.\n\nA successful split followed by a failed observation retains the completed\nmutation and command result in its error. `kill/1` returns the\ncommand result. Detached or stale references cannot act. `resize_command/2`\nbuilds a reusable value without tmux I/O; the other calls perform I/O after\nvalidation.\n\n`send_text/2` sends up to 2,000 literal bytes, including NUL, in one\ncommand using tmux's hexadecimal key form. It adds no Enter key and never\nsplits a large input into partially applied commands. `send_keys/2`\naccepts up to 256 named keys, single UTF-8 characters, {function, 1..12} and\n{control, <<Letter>>}. Named keys are enter, tab, escape, backspace, space,\nup, down, left, right, home, 'end', insert, delete, page_up, page_down and\nback_tab. Terminal modes still govern how input is consumed; command\ncompletion does not mean a program processed it.\n\n`capture/2` returns stdout bytes unchanged, including final\nnewlines. Options (`t:capture_options/0`) are start and 'end' (line\nintegers or all), join_lines, escape_sequences, escape_control,\nretain_trailing_spaces, alternate, pending and quiet. Defaults are tmux's\ncurrent-screen capture without escapes, joined wraps or padding. The\nendpoint's output limit applies; an oversized capture returns an error.\n\nUse `join/3`, `move/3` and `swap/3` to rearrange existing panes without\nrespawning their processes. `break/4` takes an explicit source window link:\nbreaking a window's only pane moves that membership, while breaking one of\nseveral panes creates a new physical window. The [topology guide](panes.md)\nshows the distinction. Use `get/2` or a new snapshot for updated parents and\nindexes; actions leave captured values unchanged.\n\n`pipe/3` connects a tmux-owned shell process to pane output, input or both.\nIt protects the shell text from tmux hash/strftime expansion; shell quoting\nremains the caller's responsibility. `stop_pipe/1` closes that native pipe.\nThese actions do not create an Erlang output subscription or transfer process\nownership to the endpoint. Use an application acknowledgement for consumer\nreadiness, delivered bytes and job completion."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane"},{"id":"tmux_pane:break/4","publicId":"tmux_pane:break/4","qualifiedName":"tmux_pane:break/4","name":"break/4","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"break(Pane, SourceLink, Session, Options)\n-spec break(tmux_model:pane(),\n            tmux_model:window_link(),\n            tmux_model:session(),\n            break_options()) ->\n               {ok, tmux_operation:completed()} |\n               {error, map()}.","references":[{"start":54,"end":69,"target":"t:tmux_model:pane/0"},{"start":85,"end":107,"target":"t:tmux_model:window_link/0"},{"start":123,"end":141,"target":"t:tmux_model:session/0"},{"start":157,"end":170,"target":"t:tmux_pane:break_options/0"},{"start":197,"end":221,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":250,"end":253,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"SourceLink","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"break_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_pane:break_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Break a physical pane through its explicit source membership into a destination session/index. Source, link and session must have the same registered owner. The source link's expected window and the pane's observed parent are checked before dispatch. The source selector also includes the stable pane ID, never its positional index. Preflight and action are not atomic.","body":"With multiple panes, tmux creates a new physical window. With only one pane,\nit moves the selected source membership, preserving the existing window and\nits other links. Moving the final membership out can remove the source session.\nPane IDs and processes remain; indexes and option inheritance can change.\nname is a literal UTF-8 argument, subject to native name cleaning.\nAn occupied destination index is refused. detach defaults true; false selects\nthe destination membership. Session groups retain native synchronization.\n\nReturns the command result consistently for both cases. Use `get/2` or\n`tmux_window_link:get/3` for fresh observations. Even an eventual native error\ncan unzoom a window; this is not a transaction and is never retried."},"source":{"line":211,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-break-4"},{"id":"tmux_pane:capture/2","publicId":"tmux_pane:capture/2","qualifiedName":"tmux_pane:capture/2","name":"capture/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"capture(Pane, Options)\n-spec capture(tmux_model:pane(), capture_options()) ->\n                 {ok, binary()} | {error, map()}.","references":[{"start":37,"end":52,"target":"t:tmux_model:pane/0"},{"start":56,"end":71,"target":"t:tmux_pane:capture_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":100,"end":106,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":120,"end":123,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"capture_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_pane:capture_options/0"}]}],"returns":"{ok, binary()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":5,"end":11,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":25,"end":28,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture terminal bytes, preserving final newlines. Options select line range, joined wraps, escapes, alternate screen and padding; defaults follow tmux current-screen capture. Performs I/O and returns an explicit output-limit error instead of silently truncating."},"source":{"line":414,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-capture-2"},{"id":"tmux_pane:get/2","publicId":"tmux_pane:get/2","qualifiedName":"tmux_pane:get/2","name":"get/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:pane_id()) ->\n             {ok, tmux_model:pane()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":61,"target":"t:tmux_model:pane_id/0"},{"start":86,"end":101,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":115,"end":118,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:pane_id()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:pane_id/0"}]}],"returns":"{ok, tmux_model:pane()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read fresh fields for a physical pane ID. Performs I/O and returns target_gone for a vanished pane. A captured PID remains an observation, not a live-process guarantee."},"source":{"line":127,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-get-2"},{"id":"tmux_pane:join/3","publicId":"tmux_pane:join/3","qualifiedName":"tmux_pane:join/3","name":"join/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"join(Source, Destination, Options)\n-spec join(tmux_model:pane(),\n           tmux_model:pane(),\n           join_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:join_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"join_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:join_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Move a source pane into a split beside the destination pane. Both physical IDs must belong to the same registered owner and must differ. Geometry follows `t:join_options/0`. Existing processes and pane IDs survive; dimensions, indexes and inherited window options can change. Removing a window's last pane destroys that physical window and its links, and can remove sessions.","body":"Default detach true avoids selecting the resolved destination session; false\nuses tmux's resolved session context for the destination pane. Shared physical\nwindows affect all their memberships. Returns the command result without\nrefreshing either row. Use `get/2` for current fields. No retry is performed."},"source":{"line":236,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-join-3"},{"id":"tmux_pane:kill/1","publicId":"tmux_pane:kill/1","qualifiedName":"tmux_pane:kill/1","name":"kill/1","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Pane)\n-spec kill(tmux_model:pane()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":22,"end":37,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":63,"end":66,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":80,"end":83,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy this registered pane. Performs I/O after validating its origin and stable ID; it never falls back to a positional target."},"source":{"line":134,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-kill-1"},{"id":"tmux_pane:move/3","publicId":"tmux_pane:move/3","qualifiedName":"tmux_pane:move/3","name":"move/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"move(Source, Destination, Options)\n-spec move(tmux_model:pane(),\n           tmux_model:pane(),\n           join_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:join_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"join_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:join_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rearrange a source pane beside the destination, including within one window. Uses native move-pane, whose placement and lifetime behavior follow `join/3`. Both calls use explicit physical IDs and leave captured rows unchanged."},"source":{"line":245,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-move-3"},{"id":"tmux_pane:pipe/3","publicId":"tmux_pane:pipe/3","qualifiedName":"tmux_pane:pipe/3","name":"pipe/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"pipe/3\n-spec pipe(tmux_model:pane(),\n           pipe_command(),\n           pipe_options()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":18,"end":33,"target":"t:tmux_model:pane/0"},{"start":48,"end":60,"target":"t:tmux_pane:pipe_command/0"},{"start":75,"end":87,"target":"t:tmux_pane:pipe_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":113,"end":116,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":130,"end":133,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Command","type":"pipe_command()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:pipe_command/0"}]},{"name":"Options","type":"pipe_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:pipe_options/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Connect a shell process to this registered physical pane, performing I/O. An explicit nonempty `#{shell => Command}` is required (`t:pipe_command/0`). tmux hash formats and strftime directives are escaped so the shell receives the supplied text. This does not quote values interpolated into shell code; the caller owns that quoting. Executable argv is not accepted by this shell-only native command. Encoding follows `tmux_command:literal_format/2` in time mode. A percent-bearing command above its native 8191-byte intermediate limit returns `format_limit` before dispatch, preserving any existing pipe.","body":"`direction` (`t:pipe_options/0`) is `output` (default: pane output to child\nstdin), `input` (child stdout to pane input) or `both`. `toggle` defaults false,\nreplacing any existing pipe. True maps to native `-o`: close an existing pipe without\nstarting another, or open one when none exists. A stopped pipe and replacement\ncan discard pending output. Await consumer acknowledgements before closing\nif delivered bytes matter. This is a live PTY byte stream, not rendered\ncapture text or replay of terminal history; terminal modes affect its bytes.\n\nThe child is started by tmux through `/bin/sh -c`. Its stderr is discarded;\nunused directions are routed to the native null device. No pane cwd or\nenvironment copying is promised. A successful command result does not prove\nexec success, readiness, delivery or child exit. The process is tmux-owned;\n`tmux_server:close/1` preserves the borrowed pane and its pipe. This is not an\nErlang subscription with library flow control. Use `stop_pipe/1` to close the\npipe; stopping is not process cancellation or a wait for job completion."},"source":{"line":165,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-pipe-3"},{"id":"tmux_pane:resize/2","publicId":"tmux_pane:resize/2","qualifiedName":"tmux_pane:resize/2","name":"resize/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"resize(Pane, Options)\n-spec resize(tmux_model:pane(), resize_options()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":35,"end":50,"target":"t:tmux_model:pane/0"},{"start":54,"end":68,"target":"t:tmux_pane:resize_options/0"},{"start":96,"end":120,"target":"t:tmux_operation:completed/0"},{"start":150,"end":172,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"resize_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_pane:resize_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Request an absolute width, height or both for this registered physical pane. Performs I/O after validating dimensions and origin. tmux can clamp the request to its layout constraints and can resize neighboring panes. Resizing a tiled pane unzooms its window. Use `get/2` for actual dimensions; the input row is unchanged. The accepted library range is not a promise that every server accepts every dimension: tmux versions can impose tighter limits and return a command error.","body":"An empty request is rejected before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_pane:resize(invalid_row, #{}).\n{error,#{code => empty_resize}}"}]},"source":{"line":317,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-resize-2"},{"id":"tmux_pane:resize_command/2","publicId":"tmux_pane:resize_command/2","qualifiedName":"tmux_pane:resize_command/2","name":"resize_command/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"resize_command(Pane, Options)\n-spec resize_command(tmux_model:pane(), resize_options()) ->\n                        {ok, tmux_command:t()} |\n                        {error, map()}.","references":[{"start":51,"end":66,"target":"t:tmux_model:pane/0"},{"start":70,"end":84,"target":"t:tmux_pane:resize_options/0"},{"start":120,"end":134,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":172,"end":175,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"resize_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_pane:resize_options/0"}]}],"returns":"{ok, tmux_command:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a resize command without tmux I/O. Uses the dimensions and validation rules of `resize/2`, preserving the row's captured origin and stable pane ID. Endpoint liveness and native layout constraints are checked during execution. Submit through `tmux_server:command/3` or `tmux_operation:start/3`.","examples":[{"lang":"erlang","code":"1> tmux_pane:resize_command(invalid_row, #{}).\n{error,#{code => empty_resize}}"}]},"source":{"line":335,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-resize_command-2"},{"id":"tmux_pane:respawn/2","publicId":"tmux_pane:respawn/2","qualifiedName":"tmux_pane:respawn/2","name":"respawn/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"respawn(Pane, Options)\n-spec respawn(tmux_model:pane(), respawn_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":37,"end":52,"target":"t:tmux_model:pane/0"},{"start":56,"end":71,"target":"t:tmux_pane:respawn_options/0"},{"start":100,"end":124,"target":"t:tmux_operation:completed/0"},{"start":155,"end":177,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"respawn_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_pane:respawn_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn this registered physical pane, keeping its pane ID. force defaults false and a running pane normally returns command_error. force = true lets tmux close its existing PTY before spawning again. This acknowledges the tmux command, not former-job termination or successful application initialization. The old PTY can already be closed if a later spawn step fails.","body":"launch defaults to previous, reusing tmux's saved argv or shell. An explicit\nargv or shell map replaces that command. default_shell is invalid here because\nabsent respawn arguments mean saved-command reuse. Omitted cwd retains the\nsaved launch directory, rather than the program's current directory. env\naugments the session environment tmux resolves for this physical pane; a\ncaptured membership does not pin that context. Prior per-spawn overrides are\nnot automatically reapplied. Other launch rules follow\n`tmux_session:create/2`.\n\nPerforms I/O after validation. Existing rows retain their observations; use\n`get/2` and an application readiness condition to inspect the new process. An\nuncertain result is not permission to replay this mutation automatically.\n\nUnsupported launch modes fail before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_pane:respawn(invalid_row, #{launch => default_shell}).\n{error,#{code => invalid_launch}}"}]},"source":{"line":373,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-respawn-2"},{"id":"tmux_pane:send_keys/2","publicId":"tmux_pane:send_keys/2","qualifiedName":"tmux_pane:send_keys/2","name":"send_keys/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"send_keys(Pane, Keys)\n-spec send_keys(tmux_model:pane(), [key()]) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":38,"end":53,"target":"t:tmux_model:pane/0"},{"start":58,"end":61,"target":"t:tmux_pane:key/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":110,"end":113,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Keys","type":"[key()]","typeReferences":[{"start":1,"end":4,"target":"t:tmux_pane:key/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send at most 256 validated key tokens. Named keys, single UTF-8 characters, function keys and control-letter tuples are supported. Performs I/O; terminal modes determine the resulting input bytes. Use `send_text/2` for arbitrary bytes."},"source":{"line":401,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-send_keys-2"},{"id":"tmux_pane:send_text/2","publicId":"tmux_pane:send_text/2","qualifiedName":"tmux_pane:send_text/2","name":"send_text/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"send_text/2\n-spec send_text(tmux_model:pane(), binary()) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":28,"end":43,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":47,"end":53,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":84,"end":87,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":101,"end":104,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Bytes","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Send at most 2,000 literal bytes as hexadecimal tmux keys. Adds no Enter key and does not invoke a shell. Performs I/O in one command; oversized input is rejected before partial submission. Completion does not prove that a terminal program processed the input."},"source":{"line":388,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-send_text-2"},{"id":"tmux_pane:split/2","publicId":"tmux_pane:split/2","qualifiedName":"tmux_pane:split/2","name":"split/2","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"split(Row, Options)\n-spec split(tmux_model:pane() | tmux_model:window(),\n            split_options()) ->\n               {ok, tmux_model:pane()} | {error, map()}.","references":[{"start":32,"end":47,"target":"t:tmux_model:pane/0"},{"start":52,"end":69,"target":"t:tmux_model:window/0"},{"start":85,"end":98,"target":"t:tmux_pane:split_options/0"},{"start":125,"end":140,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":154,"end":157,"target":"t:erlang:map/0"}],"params":[{"name":"Row","type":"tmux_model:pane() | tmux_model:window()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"},{"start":20,"end":37,"target":"t:tmux_model:window/0"}]},{"name":"Options","type":"split_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_pane:split_options/0"}]}],"returns":"{ok, tmux_model:pane()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Split a pane, or the supplied window's active pane, and observe the new pane. Defaults to a detached vertical split. Options and launch semantics are described in the module docs. Performs I/O; a post-creation read error retains the completed mutation rather than pretending that no pane was created."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-split-2"},{"id":"tmux_pane:stop_pipe/1","publicId":"tmux_pane:stop_pipe/1","qualifiedName":"tmux_pane:stop_pipe/1","name":"stop_pipe/1","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"stop_pipe(Pane)\n-spec stop_pipe(tmux_model:pane()) ->\n                   {ok, map()} | {error, map()}.","references":[{"start":32,"end":47,"target":"t:tmux_model:pane/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":78,"end":81,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":95,"end":98,"target":"t:erlang:map/0"}],"params":[{"name":"Pane","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Close this registered pane's native pipe, performing I/O. On a live pane, closing an already closed pipe succeeds. An exited pane can produce a native command error; a vanished ID returns `target_gone`.","body":"Closing can discard pending bytes. It neither kills nor waits for an arbitrary\nshell job started by `pipe/3`; applications must verify consumption and\nprocess completion themselves. The endpoint does not own that shell process."},"source":{"line":188,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-stop_pipe-1"},{"id":"tmux_pane:swap/3","publicId":"tmux_pane:swap/3","qualifiedName":"tmux_pane:swap/3","name":"swap/3","namespace":"tmux_pane","parent":"tmux_pane","kind":"function","modifiers":[],"signatures":[{"raw":"swap(Source, Destination, Options)\n-spec swap(tmux_model:pane(),\n           tmux_model:pane(),\n           swap_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, map()}.","references":[{"start":46,"end":61,"target":"t:tmux_model:pane/0"},{"start":76,"end":91,"target":"t:tmux_model:pane/0"},{"start":106,"end":118,"target":"t:tmux_pane:swap_options/0"},{"start":144,"end":168,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":196,"end":199,"target":"t:erlang:map/0"}],"params":[{"name":"Source","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Destination","type":"tmux_model:pane()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_model:pane/0"}]},{"name":"Options","type":"swap_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_pane:swap_options/0"}]}],"returns":"{ok, tmux_operation:completed()} | {error, map()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":43,"end":46,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Exchange two panes' layout positions within or across physical windows. Preserves their IDs and processes; parent windows, dimensions, indexes and inherited options can change. Both rows require the same registered owner. detach defaults true; active positions can still receive different panes. zoom maps to native -Z. Identical IDs do not exchange panes, but native zoom handling still runs; the default can unzoom even a same-pane swap. Returns the command result; `get/2` observes the resulting values explicitly."},"source":{"line":258,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_pane-swap-3"},{"id":"t:tmux_pane:break_options/0","publicId":"t:tmux_pane:break_options/0","qualifiedName":"tmux_pane:break_options/0","name":"break_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type break_options() ::\n          #{index := tmux_window_link:index(),\n            name => binary(),\n            detach => boolean()}.","params":[],"references":[{"start":46,"end":68,"target":"t:tmux_window_link:index/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":92,"end":98,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":124,"end":131,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Break placement: explicit destination index, optional literal window name. detach defaults true."},"source":{"line":66,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-break_options-0"},{"id":"t:tmux_pane:capture_options/0","publicId":"t:tmux_pane:capture_options/0","qualifiedName":"tmux_pane:capture_options/0","name":"capture_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capture_options() ::\n          #{start => coordinate(),\n            'end' => coordinate(),\n            join_lines => boolean(),\n            escape_sequences => boolean(),\n            escape_control => boolean(),\n            retain_trailing_spaces => boolean(),\n            alternate => boolean(),\n            pending => boolean(),\n            quiet => boolean()}.","params":[],"references":[{"start":48,"end":58,"target":"t:tmux_pane:coordinate/0"},{"start":83,"end":93,"target":"t:tmux_pane:coordinate/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":123,"end":130,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":166,"end":173,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":207,"end":214,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":256,"end":263,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":292,"end":299,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":326,"end":333,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":358,"end":365,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture range and rendering flags. Byte output and its final newline are preserved."},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-capture_options-0"},{"id":"t:tmux_pane:coordinate/0","publicId":"t:tmux_pane:coordinate/0","qualifiedName":"tmux_pane:coordinate/0","name":"coordinate/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type coordinate() :: -2147483648..32767 | all.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A capture line coordinate, or all for tmux's full available range."},"source":{"line":91,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-coordinate-0"},{"id":"t:tmux_pane:join_options/0","publicId":"t:tmux_pane:join_options/0","qualifiedName":"tmux_pane:join_options/0","name":"join_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type join_options() ::\n          #{direction => horizontal | vertical,\n            size =>\n                {cells, 1..2147483647} | {percent, 1..100},\n            detach => boolean(),\n            before => boolean(),\n            full_size => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":174,"end":181,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":207,"end":214,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":243,"end":250,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Join/move geometry: detach true, vertical split by default. before and full_size follow tmux layout rules."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-join_options-0"},{"id":"t:tmux_pane:key/0","publicId":"t:tmux_pane:key/0","qualifiedName":"tmux_pane:key/0","name":"key/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type key() ::\n          binary() |\n          enter | tab | escape | backspace | space | up |\n          down | left | right | home | 'end' | insert |\n          delete | page_up | page_down | back_tab |\n          {function, 1..12} |\n          {control, binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":25,"end":31,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":252,"end":258,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A validated named key, single UTF-8 character, function key or control-letter key."},"source":{"line":97,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-key-0"},{"id":"t:tmux_pane:pipe_command/0","publicId":"t:tmux_pane:pipe_command/0","qualifiedName":"tmux_pane:pipe_command/0","name":"pipe_command/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pipe_command() :: #{shell := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":35,"end":41,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicit shell code: a nonempty NUL-free binary, with no tmux format or strftime expansion."},"source":{"line":59,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-pipe_command-0"},{"id":"t:tmux_pane:pipe_options/0","publicId":"t:tmux_pane:pipe_options/0","qualifiedName":"tmux_pane:pipe_options/0","name":"pipe_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type pipe_options() ::\n          #{direction => output | input | both,\n            toggle => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":94,"end":101,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Pipe direction defaults to output. toggle defaults false; true closes an existing pipe instead of replacing it."},"source":{"line":61,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-pipe_options-0"},{"id":"t:tmux_pane:resize_options/0","publicId":"t:tmux_pane:resize_options/0","qualifiedName":"tmux_pane:resize_options/0","name":"resize_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type resize_options() ::\n          #{width := 1..65535, height => 1..65535} |\n          #{width => 1..65535, height := 1..65535}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Requested absolute pane dimensions in cells. Supply at least one dimension; tmux can clamp it to fit the layout."},"source":{"line":85,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-resize_options-0"},{"id":"t:tmux_pane:respawn_options/0","publicId":"t:tmux_pane:respawn_options/0","qualifiedName":"tmux_pane:respawn_options/0","name":"respawn_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_options() ::\n          #{force => boolean(),\n            launch => tmux_command:respawn_spec(),\n            cwd => binary(),\n            env => #{binary() => binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"start":81,"end":106,"target":"t:tmux_command:respawn_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":129,"end":135,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":172,"end":178,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn options. Defaults: force false, launch previous, saved cwd. Environment augments tmux's resolved session environment for this spawn."},"source":{"line":88,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-respawn_options-0"},{"id":"t:tmux_pane:split_options/0","publicId":"t:tmux_pane:split_options/0","qualifiedName":"tmux_pane:split_options/0","name":"split_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type split_options() ::\n          #{direction => horizontal | vertical,\n            size =>\n                {cells, 1..2147483647} | {percent, 1..100},\n            before => boolean(),\n            full_size => boolean(),\n            zoom => boolean(),\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":175,"end":182,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":211,"end":218,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":242,"end":249,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":272,"end":278,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":303,"end":309,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":315,"end":321,"target":"t:erlang:binary/0"},{"start":348,"end":372,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":398,"end":405,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Split geometry, placement and explicit launch options. Defaults to a detached vertical split."},"source":{"line":80,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-split_options-0"},{"id":"t:tmux_pane:swap_options/0","publicId":"t:tmux_pane:swap_options/0","qualifiedName":"tmux_pane:swap_options/0","name":"swap_options/0","namespace":"tmux_pane","parent":"tmux_pane","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type swap_options() ::\n          #{detach => boolean(), zoom => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":46,"end":53,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":65,"end":72,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Swap controls: detach defaults true; zoom maps to tmux -Z to retain zoom."},"source":{"line":78,"file":"apps/libtmux_erlang/src/tmux_pane.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_pane-swap_options-0"},{"id":"tmux_query","publicId":"tmux_query","qualifiedName":"tmux_query","name":"tmux_query","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Build and execute explicit queries over the tmux graph.","body":"Use `fetch/1` to execute a query. Constructors,\n`where/2`, `limit/2`, `pushdown/2` and\n`explain/1` perform no tmux I/O. Criteria are validated when added,\nand repeated conditions conjoin. Fetching returns an ordered `m:tmux_select`\nselection backed by a complete `m:tmux_snapshot` graph. By default the full\ncaptured view is filtered locally. Enable native candidate exclusion with\n`pushdown/2`: it can add a scan without reducing complete-graph hydration. The\ncandidate is a necessary condition; the full filter still runs before the limit.\n\nCaptures span commands and are not atomic. Candidate IDs excluded at one\nobservation cannot be recovered by later local filtering. Disabling\n`pushdown/2` evaluates the complete captured view without an\nearlier candidate exclusion. Numeric candidate fields come from the restricted\nscalar codec and must agree with the capture's scalar observations. Text and\nrelationships remain local.\n\nCaptures emit bounded OTP Logger reports with their snapshot ID and endpoint\ngeneration. See [runtime diagnostics](diagnostics.md) for observation cost,\nrejection reports and configuration.","examples":[{"lang":"erlang","code":"1> Q0 = tmux_query:panes(unopened), ok.\nok\n2> Q = tmux_query:where(#{width => #{gte => 120}}, Q0), ok.\nok\n3> maps:get(format, maps:get(candidate, tmux_query:explain(Q))).\n<<\"1\">>\n4> Pushed = tmux_query:pushdown(true, Q), ok.\nok\n5> maps:get(format, maps:get(candidate, tmux_query:explain(Pushed))).\n<<\"#{e|>=|:#{pane_width},120}\">>"}]},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query"},{"id":"tmux_query:explain/1","publicId":"tmux_query:explain/1","qualifiedName":"tmux_query:explain/1","name":"explain/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"explain/1\n-spec explain(t()) -> plan().","references":[{"start":24,"end":25,"target":"t:tmux_query:t/0"},{"start":32,"end":36,"target":"t:tmux_query:plan/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"plan()","returnsReferences":[{"start":0,"end":4,"target":"t:tmux_query:plan/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Inspect command templates, necessary candidate conditions, full residual, hydration, required fields, ordering and temporal assumptions. Performs no I/O and does not contact the endpoint to claim dynamic capabilities."},"source":{"line":191,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-explain-1"},{"id":"tmux_query:fetch/1","publicId":"tmux_query:fetch/1","qualifiedName":"tmux_query:fetch/1","name":"fetch/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"fetch(Query)\n-spec fetch(t()) -> {ok, tmux_select:t()} | {error, map()}.","references":[{"start":25,"end":26,"target":"t:tmux_query:t/0"},{"start":38,"end":51,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":65,"end":68,"target":"t:erlang:map/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"{ok, tmux_select:t()} | {error, map()}","returnsReferences":[{"start":5,"end":18,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute with default capture bounds and no retry. Returns an ordered selection whose complete graph remains locally readable. See `fetch/2` for resource limits, requested retries and operational errors."},"source":{"line":215,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-fetch-1"},{"id":"tmux_query:fetch/2","publicId":"tmux_query:fetch/2","qualifiedName":"tmux_query:fetch/2","name":"fetch/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"fetch/2\n-spec fetch(t(), fetch_options()) ->\n               {ok, tmux_select:t()} | {error, map()}.","references":[{"start":20,"end":21,"target":"t:tmux_query:t/0"},{"start":25,"end":38,"target":"t:tmux_query:fetch_options/0"},{"start":65,"end":78,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]},{"name":"Options","type":"fetch_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_query:fetch_options/0"}]}],"returns":"{ok, tmux_select:t()} | {error, map()}","returnsReferences":[{"start":5,"end":18,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":32,"end":35,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute the planned observation, full local predicate and final limit.","body":"Capture options are those of `tmux_server:snapshot/2`. retry is 0 (default) or\n1 and retries only inconsistent_capture, within the original capture deadline.\nThe retry is a new read-only capture. No mutations are retried. Invalid\ncapture requests return tagged errors, including unsupported consistency.","examples":[{"lang":"erlang","code":"1> tmux_query:fetch(tmux_query:panes(unopened), #{retry => 2}).\n{error,#{code => invalid_query_options}}"}]},"source":{"line":231,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-fetch-2"},{"id":"tmux_query:limit/2","publicId":"tmux_query:limit/2","qualifiedName":"tmux_query:limit/2","name":"limit/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"limit/2\n-spec limit(0..65536, t()) -> t().","references":[{"start":30,"end":31,"target":"t:tmux_query:t/0"},{"start":38,"end":39,"target":"t:tmux_query:t/0"}],"params":[{"name":"Count","type":"0..65536","typeReferences":[]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Set a final result limit from 0 through 65536, applied after residual filtering and identity handling. It is not a candidate-fetch limit. Performs no I/O; invalid counts raise bad_query_limit."},"source":{"line":172,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-limit-2"},{"id":"tmux_query:panes/1","publicId":"tmux_query:panes/1","qualifiedName":"tmux_query:panes/1","name":"panes/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Server)\n-spec panes(tmux_server:t()) -> t().","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":46,"end":47,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future server-wide physical pane query. Performs no I/O; `fetch/1` is the execution boundary."},"source":{"line":128,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-panes-1"},{"id":"tmux_query:pushdown/2","publicId":"tmux_query:pushdown/2","qualifiedName":"tmux_query:pushdown/2","name":"pushdown/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"pushdown(Enabled, Query)\n-spec pushdown(boolean(), t()) -> t().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":40,"end":47,"target":"t:erlang:boolean/0"},{"start":51,"end":52,"target":"t:tmux_query:t/0"},{"start":59,"end":60,"target":"t:tmux_query:t/0"}],"params":[{"name":"Enabled","type":"boolean()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Enable or disable native candidate exclusion, returning a new query. The default is disabled: evaluate the complete captured view locally. Enabling it can add a candidate scan without reducing hydration; neither mode promises an atomic graph. Performs no I/O."},"source":{"line":183,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-pushdown-2"},{"id":"tmux_query:sessions/1","publicId":"tmux_query:sessions/1","qualifiedName":"tmux_query:sessions/1","name":"sessions/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Server)\n-spec sessions(tmux_server:t()) -> t().","references":[{"start":32,"end":45,"target":"t:tmux_server:t/0"},{"start":52,"end":53,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future server-wide session query without executing tmux."},"source":{"line":144,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-sessions-1"},{"id":"tmux_query:where/2","publicId":"tmux_query:where/2","qualifiedName":"tmux_query:where/2","name":"where/2","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"where/2\n-spec where(map() | tmux_filter:t(), t()) -> t().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"start":28,"end":41,"target":"t:tmux_filter:t/0"},{"start":45,"end":46,"target":"t:tmux_query:t/0"},{"start":53,"end":54,"target":"t:tmux_query:t/0"}],"params":[{"name":"Criteria","type":"map() | tmux_filter:t()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"},{"start":8,"end":21,"target":"t:tmux_filter:t/0"}]},{"name":"Query","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate trusted criteria for this entity and conjoin them with prior conditions. Successive calls share the same normalized resource limits as one flat conjunction. Each relationship quantifier retains its own scope. Returns a new immutable query; malformed criteria raise bad_filter. Performs no I/O."},"source":{"line":153,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-where-2"},{"id":"tmux_query:window_links/1","publicId":"tmux_query:window_links/1","qualifiedName":"tmux_query:window_links/1","name":"window_links/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Server)\n-spec window_links(tmux_server:t()) -> t().","references":[{"start":40,"end":53,"target":"t:tmux_server:t/0"},{"start":60,"end":61,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future query over session-relative window memberships. Repeated physical windows retain distinct membership identity. Performs no I/O."},"source":{"line":139,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-window_links-1"},{"id":"tmux_query:windows/1","publicId":"tmux_query:windows/1","qualifiedName":"tmux_query:windows/1","name":"windows/1","namespace":"tmux_query","parent":"tmux_query","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Server)\n-spec windows(tmux_server:t()) -> t().","references":[{"start":30,"end":43,"target":"t:tmux_server:t/0"},{"start":50,"end":51,"target":"t:tmux_query:t/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]}],"returns":"t()","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_query:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Describe a future query over unique physical windows. Performs no I/O."},"source":{"line":133,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_query-windows-1"},{"id":"t:tmux_query:candidate/0","publicId":"t:tmux_query:candidate/0","qualifiedName":"tmux_query:candidate/0","name":"candidate/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type candidate() ::\n          #{format := binary(),\n            exact := boolean(),\n            local_only := [local_reason()],\n            numeric_range => {0, 9007199254740991}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":43,"end":49,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":74,"end":81,"target":"t:erlang:boolean/0"},{"start":112,"end":124,"target":"t:tmux_query:local_reason/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Native necessary condition. format is a rendered tmux expression; exact means the translation covers the whole predicate for one observed state. A true fallback can admit every row. numeric_range describes qualified integer conversion, and is omitted for disabled/oversized fallback plans."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-candidate-0"},{"id":"t:tmux_query:command_plan/0","publicId":"t:tmux_query:command_plan/0","qualifiedName":"tmux_query:command_plan/0","name":"command_plan/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_plan() ::\n          #{initial_spine := [source_command()],\n            candidate := [source_command()],\n            hydration := [source_command()],\n            isolated_hydration := [source_command()],\n            final_spine := [source_command()],\n            empty_server := skip_window_and_pane_scans}.","params":[],"references":[{"start":54,"end":68,"target":"t:tmux_query:source_command/0"},{"start":99,"end":113,"target":"t:tmux_query:source_command/0"},{"start":144,"end":158,"target":"t:tmux_query:source_command/0"},{"start":198,"end":212,"target":"t:tmux_query:source_command/0"},{"start":245,"end":259,"target":"t:tmux_query:source_command/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture phases: initial identity/scalar scans, optional candidate scans, complete text/byte hydration and final identity/scalar scans. hydration gives the default batched templates; isolated_hydration describes the explicit isolated option and unqualified-field fallback. An empty server skips window/pane scans. Execution still validates capture bounds and can fail."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-command_plan-0"},{"id":"t:tmux_query:fetch_options/0","publicId":"t:tmux_query:fetch_options/0","qualifiedName":"tmux_query:fetch_options/0","name":"fetch_options/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type fetch_options() ::\n          #{deadline_ms => 1..600000,\n            max_rows => 1..65536,\n            max_bytes => 1..67108864,\n            hydration => tmux_server:hydration(),\n            consistency => observed | atomic,\n            retry => 0 | 1}.","params":[],"references":[{"start":160,"end":181,"target":"t:tmux_server:hydration/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture bounds plus an explicitly requested single inconsistent-capture retry; default retry is zero."},"source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-fetch_options-0"},{"id":"t:tmux_query:local_reason/0","publicId":"t:tmux_query:local_reason/0","qualifiedName":"tmux_query:local_reason/0","name":"local_reason/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type local_reason() ::\n          #{reason :=\n                disabled | format_limit | inexact_negation |\n                unqualified_scalar_codec |\n                complete_relationship_required,\n            field => binary(),\n            relation => binary(),\n            operator => tmux_schema:operator()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":219,"end":225,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":253,"end":259,"target":"t:erlang:binary/0"},{"start":287,"end":307,"target":"t:tmux_schema:operator/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Why part of a predicate stays local. field and relation contain stable schema IDs, not Erlang names or tmux formats. An unsupported leaf may broaden the native condition; it never removes the full local predicate."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-local_reason-0"},{"id":"t:tmux_query:plan/0","publicId":"t:tmux_query:plan/0","qualifiedName":"tmux_query:plan/0","name":"plan/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type plan() ::\n          #{entity := tmux_schema:entity(),\n            pushdown := boolean(),\n            candidate := candidate(),\n            residual := tmux_filter:wire_document(),\n            required := [tmux_snapshot:requirement()],\n            limit := infinity | 0..65536,\n            commands := command_plan(),\n            hydration := complete_graph,\n            ordering := session_index_window | numeric_id,\n            deduplication := membership | physical_id,\n            capabilities :=\n                #{minimum_tmux := binary(),\n                  transport := one_shot},\n            consistency := observed,\n            atomic := false,\n            candidate_scalars :=\n                same_row_checked_against_spine,\n            text_and_relations := later_observations,\n            temporal_limit :=\n                excluded_rows_cannot_be_recovered}.","params":[],"references":[{"start":38,"end":56,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":84,"end":91,"target":"t:erlang:boolean/0"},{"start":120,"end":129,"target":"t:tmux_query:candidate/0"},{"start":157,"end":182,"target":"t:tmux_filter:wire_document/0"},{"start":211,"end":236,"target":"t:tmux_snapshot:requirement/0"},{"start":307,"end":319,"target":"t:tmux_query:command_plan/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":540,"end":546,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Pure explanation of a query. pushdown reports whether candidate exclusion is enabled (disabled by default). residual is the full portable predicate, required lists coverage requirements, and limit applies after residual evaluation. ordering and deduplication name the identity policy, not arbitrary map order. capabilities describes the planner baseline without probing a live endpoint.","body":"Capture spans commands. Candidate scalar values are checked against the first\nscan; text and relationships are later observations. Excluded rows cannot be\nrecovered after state changes. Even an exact candidate is not an atomic query."},"source":{"line":107,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-plan-0"},{"id":"t:tmux_query:source_command/0","publicId":"t:tmux_query:source_command/0","qualifiedName":"tmux_query:source_command/0","name":"source_command/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_command() ::\n          #{entity := tmux_schema:entity(),\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := scalar_spine,\n            kind := tmux_schema:entity(),\n            args := [binary()],\n            filter => binary()} |\n          #{entity := tmux_schema:entity(),\n            fields := [atom()],\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := escaped_columns_v1,\n            args := [binary()]} |\n          #{entity := tmux_schema:entity(),\n            field := atom(),\n            command := binary(),\n            format := binary(),\n            transport := one_shot,\n            codec := id_prefixed_quoted_field,\n            target := observed_id}.","params":[],"references":[{"start":48,"end":66,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":93,"end":99,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":125,"end":131,"target":"t:erlang:binary/0"},{"start":225,"end":243,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":268,"end":274,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":301,"end":307,"target":"t:erlang:binary/0"},{"start":335,"end":353,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":380,"end":384,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":412,"end":418,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":444,"end":450,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":551,"end":557,"target":"t:erlang:binary/0"},{"start":586,"end":604,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":629,"end":633,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":660,"end":666,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":692,"end":698,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Diagnostic command template, not executable argv. Scan templates carry args; text/byte hydration escapes each field once before column framing. Unqualified schema fields use isolated target = observed_id templates, resolved only while capturing. codec states how returned data is framed, including the version-specific print layer. This value grants no atomicity or persistent-connection guarantee."},"source":{"line":75,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-source_command-0"},{"id":"t:tmux_query:t/0","publicId":"t:tmux_query:t/0","qualifiedName":"tmux_query:t/0","name":"t/0","namespace":"tmux_query","parent":"tmux_query","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An immutable description of future tmux reads. Only fetch executes it."},"source":{"line":121,"file":"apps/libtmux_erlang/src/tmux_query.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_query-t-0"},{"id":"tmux_schema","publicId":"tmux_schema","qualifiedName":"tmux_schema","name":"tmux_schema","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Validate schema-defined observations and normalize scalar values.","body":"Field names come from the generated registry, never record reflection or\npayload-created atoms. Text is validated UTF-8; byte fields preserve arbitrary\nbinaries. Integer normalization uses the shared exact JSON integer range.\n`m:tmux_model` validates rows and `m:tmux_filter` validates criteria through\nthis schema. The [field reference](fields.md) lists fields and relationships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema"},{"id":"tmux_schema:field/2","publicId":"tmux_schema:field/2","qualifiedName":"tmux_schema:field/2","name":"field/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"field(Entity, Field)\n-spec field(entity(), atom()) ->\n               {ok, field_metadata()} |\n               {error, error_detail()}.","references":[{"start":33,"end":39,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":43,"end":47,"target":"t:erlang:atom/0"},{"start":74,"end":88,"target":"t:tmux_schema:field_metadata/0"},{"start":117,"end":129,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]},{"name":"Field","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]}],"returns":"{ok, field_metadata()} | {error, error_detail()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_schema:field_metadata/0"},{"start":33,"end":45,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up one permitted field by its Erlang atom name. Unknown names return a tagged error; this does not turn input strings into atoms."},"source":{"line":78,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-field-2"},{"id":"tmux_schema:fields/1","publicId":"tmux_schema:fields/1","qualifiedName":"tmux_schema:fields/1","name":"fields/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"fields(Entity)\n-spec fields(entity()) ->\n                {ok, #{atom() => field_metadata()}} |\n                {error, error_detail()}.","references":[{"start":28,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":64,"end":68,"target":"t:erlang:atom/0"},{"start":74,"end":88,"target":"t:tmux_schema:field_metadata/0"},{"start":119,"end":131,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]}],"returns":"{ok, #{atom() => field_metadata()}} |\n          {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":7,"end":11,"target":"t:erlang:atom/0"},{"start":17,"end":31,"target":"t:tmux_schema:field_metadata/0"},{"start":56,"end":68,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return generated field metadata for a known entity, or a tagged unknown_entity error. Field names, wire names and stable IDs are allowlisted; this is not reflection over arbitrary record fields."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-fields-1"},{"id":"tmux_schema:normalize/2","publicId":"tmux_schema:normalize/2","qualifiedName":"tmux_schema:normalize/2","name":"normalize/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"normalize/2\n-spec normalize(entity(), map()) ->\n                   {ok, map()} | {error, error_detail()}.","references":[{"start":28,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":38,"end":41,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":72,"end":75,"target":"t:erlang:map/0"},{"start":89,"end":101,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]},{"name":"Input","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]}],"returns":"{ok, map()} | {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"start":22,"end":34,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate a domain-field map and normalize its scalar observations, retaining not_loaded/unavailable distinctly and deriving schema-defined values. Performs no I/O; constructors and action boundaries still validate records."},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-normalize-2"},{"id":"tmux_schema:operators/1","publicId":"tmux_schema:operators/1","qualifiedName":"tmux_schema:operators/1","name":"operators/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"operators/1\n-spec operators(#{type := value_type(),\n                  nullable := boolean(),\n                  atom() => term()}) ->\n                   [operator()].","references":[{"start":38,"end":48,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":82,"end":89,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":121,"end":125,"target":"t:erlang:term/0"},{"start":153,"end":161,"target":"t:tmux_schema:operator/0"}],"params":[{"name":"Argument1","type":"#{type := value_type(),\n            nullable := boolean(),\n            atom() => term()}","typeReferences":[{"start":10,"end":20,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":71,"end":75,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":81,"end":85,"target":"t:erlang:term/0"}]}],"returns":"[operator()]","returnsReferences":[{"start":1,"end":9,"target":"t:tmux_schema:operator/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the permitted scalar operators for this field type and nullability. The generated field reference uses this same validator. Performs no I/O."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-operators-1"},{"id":"tmux_schema:relations/1","publicId":"tmux_schema:relations/1","qualifiedName":"tmux_schema:relations/1","name":"relations/1","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"relations(Entity)\n-spec relations(entity()) ->\n                   {ok, #{atom() => relation_metadata()}} |\n                   {error, error_detail()}.","references":[{"start":34,"end":40,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":73,"end":77,"target":"t:erlang:atom/0"},{"start":83,"end":100,"target":"t:tmux_schema:relation_metadata/0"},{"start":134,"end":146,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Entity","type":"entity()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_schema:entity/0"}]}],"returns":"{ok, #{atom() => relation_metadata()}} |\n          {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":7,"end":11,"target":"t:erlang:atom/0"},{"start":17,"end":34,"target":"t:tmux_schema:relation_metadata/0"},{"start":59,"end":71,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return generated relationship metadata, including target entities and one/many cardinality. Performs no I/O."},"source":{"line":67,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-relations-1"},{"id":"tmux_schema:value/2","publicId":"tmux_schema:value/2","qualifiedName":"tmux_schema:value/2","name":"value/2","namespace":"tmux_schema","parent":"tmux_schema","kind":"function","modifiers":[],"signatures":[{"raw":"value/2\n-spec value(map(), term()) ->\n               {ok, term()} | {error, error_detail()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":27,"end":31,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":58,"end":62,"target":"t:erlang:term/0"},{"start":76,"end":88,"target":"t:tmux_schema:error_detail/0"}],"params":[{"name":"Argument1","type":"map()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":0,"end":3,"target":"t:erlang:map/0"}]},{"name":"Argument2","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]}],"returns":"{ok, term()} | {error, error_detail()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":5,"end":9,"target":"t:erlang:term/0"},{"start":23,"end":35,"target":"t:tmux_schema:error_detail/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate and normalize one value against generated field metadata. Integral JSON numbers obey the exact shared integer range and field bounds; text is validated UTF-8, while bytes remain arbitrary binaries. Performs no I/O."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_schema-value-2"},{"id":"t:tmux_schema:entity/0","publicId":"t:tmux_schema:entity/0","qualifiedName":"tmux_schema:entity/0","name":"entity/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type entity() :: session | window | window_link | pane.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"The built-in tmux graph entities; window_link represents a session membership."},"source":{"line":18,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-entity-0"},{"id":"t:tmux_schema:error_detail/0","publicId":"t:tmux_schema:error_detail/0","qualifiedName":"tmux_schema:error_detail/0","name":"error_detail/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type error_detail() ::\n          #{code := atom(),\n            path := [term()],\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":44,"end":48,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":73,"end":77,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":94,"end":98,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":104,"end":108,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Structured boundary validation errors with a code and input path."},"source":{"line":22,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-error_detail-0"},{"id":"t:tmux_schema:field_metadata/0","publicId":"t:tmux_schema:field_metadata/0","qualifiedName":"tmux_schema:field_metadata/0","name":"field_metadata/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type field_metadata() ::\n          #{type := value_type(),\n            wire := binary(),\n            stable := binary(),\n            required := boolean(),\n            nullable := boolean(),\n            format => binary(),\n            capture_codec => escaped_columns_v1,\n            minimum => integer()}.","params":[],"references":[{"start":46,"end":56,"target":"t:tmux_schema:value_type/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":80,"end":86,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":112,"end":118,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":146,"end":153,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":181,"end":188,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":214,"end":220,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":296,"end":303,"target":"t:erlang:integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Generated field contract. stable is a versioned portable identity; wire is the JSON key. required controls construction and nullable permits known absence. format is present only for directly observed tmux fields; derived fields omit it. capture_codec identifies an admitted batched source encoding; its absence selects isolated reads for that entity. minimum tightens an integer field's lower bound. Field names themselves are the keys returned by `fields/1`, not this map's wire or stable values."},"source":{"line":35,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-field_metadata-0"},{"id":"t:tmux_schema:operator/0","publicId":"t:tmux_schema:operator/0","qualifiedName":"tmux_schema:operator/0","name":"operator/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type operator() ::\n          equals | 'not' | in | not_in | lt | lte | gt |\n          gte | contains | starts_with | ends_with | regex |\n          present.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validated scalar operators. The field's type and nullability restrict this set."},"source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-operator-0"},{"id":"t:tmux_schema:relation_metadata/0","publicId":"t:tmux_schema:relation_metadata/0","qualifiedName":"tmux_schema:relation_metadata/0","name":"relation_metadata/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type relation_metadata() ::\n          #{kind := one | many,\n            target := entity(),\n            wire := binary(),\n            stable := binary()}.","params":[],"references":[{"start":83,"end":89,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":113,"end":119,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":145,"end":151,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Generated relationship contract: kind is one or many; target names the related entity. wire and stable have the same roles as in `t:field_metadata/0`. Completeness belongs to snapshot coverage, not this static schema."},"source":{"line":43,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-relation_metadata-0"},{"id":"t:tmux_schema:value_type/0","publicId":"t:tmux_schema:value_type/0","qualifiedName":"tmux_schema:value_type/0","name":"value_type/0","namespace":"tmux_schema","parent":"tmux_schema","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type value_type() ::\n          session_id | window_id | pane_id | boolean |\n          uint | integer | text | bytes.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Scalar categories used by normalization and operator validation; IDs remain binaries."},"source":{"line":24,"file":"apps/libtmux_erlang/src/tmux_schema.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_schema-value_type-0"},{"id":"tmux_scope","publicId":"tmux_scope","qualifiedName":"tmux_scope","name":"tmux_scope","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Run synchronous work and cleanup while preserving both outcomes.","body":"Use `run/2` around a resource whose handle remains in the caller's scope.\nUse `run_or_error/2` for nested scopes or fail-fast programs that need the\ncallback's value directly and raise when cleanup fails.\n`tmux_server:with_server/2` and `tmux_server:with_owned/2` also acquire their\nresources and add recovery handles when cleanup fails. This module owns no\nprocess, timeout or retry policy; the supplied functions own those contracts."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_scope"},{"id":"tmux_scope:run/2","publicId":"tmux_scope:run/2","qualifiedName":"tmux_scope:run/2","name":"run/2","namespace":"tmux_scope","parent":"tmux_scope","kind":"function","modifiers":[],"signatures":[{"raw":"run(Function, Cleanup)\n-spec run(fun(() -> Value),\n          fun(() -> ok | {error, term()})) ->\n             {ok, Value} | {error, failure()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":84,"end":88,"target":"t:erlang:term/0"},{"start":132,"end":139,"target":"t:tmux_scope:failure/0"}],"params":[{"name":"Function","type":"fun(() -> Value)","typeReferences":[]},{"name":"Cleanup","type":"fun(() -> ok | {error, term()})","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"returns":"{ok, Value} | {error, failure()}","returnsReferences":[{"start":22,"end":29,"target":"t:tmux_scope:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Run a callback, then attempt cleanup once, synchronously in the calling process. This function performs only the I/O supplied by those functions. The callback has no library duration timer. Abrupt uncatchable caller death remains subject to each resource's existing ownership policy.","body":"Only ok proves cleanup success. Normalize resource-specific successful replies\ninside the cleanup function. With successful cleanup, return {ok, Value} or\nre-raise the original callback exception with its reason and stack. A callback\nreturning an error tuple is an ordinary value. Cleanup failure instead returns\n{error, Failure} with `t:failure/0`, preserving both outcomes. An unexpected\ncleanup return is recorded as invalid_cleanup_result.\n\nHandle an inner scope's error explicitly when nesting scopes. Otherwise it is\nan ordinary outer callback value. Keep resource handles for recovery; this\nfunction does not infer ownership or retry cleanup.","examples":[{"lang":"erlang","code":"1> tmux_scope:run(fun() -> done end, fun() -> ok end).\n{ok,done}\n2> tmux_scope:run(fun() -> done end, fun() -> {error, enoent} end).\n{error,#{code => scope_cleanup_failed,\n         primary => {ok,done},cleanup => {error,enoent}}}\n3> Work = fun() -> error(build_failed) end, ok.\nok\n4> {error, F} = tmux_scope:run(Work, fun() -> {error, busy} end), ok.\nok\n5> {exception, error, build_failed, [_ | _]} = maps:get(primary, F), ok.\nok\n6> maps:get(cleanup, F).\n{error,busy}"}]},"source":{"line":61,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_scope-run-2"},{"id":"tmux_scope:run_or_error/2","publicId":"tmux_scope:run_or_error/2","qualifiedName":"tmux_scope:run_or_error/2","name":"run_or_error/2","namespace":"tmux_scope","parent":"tmux_scope","kind":"function","modifiers":[],"signatures":[{"raw":"run_or_error(Function, Cleanup)\n-spec run_or_error(fun(() -> Value),\n                   fun(() -> ok | {error, term()})) ->\n                      Value.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:term/0"}],"params":[{"name":"Function","type":"fun(() -> Value)","typeReferences":[]},{"name":"Cleanup","type":"fun(() -> ok | {error, term()})","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"returns":"Value","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Run work and cleanup with `run/2`, returning the callback value directly. Raises {scope_cleanup_failed, Failure} if cleanup fails, retaining both outcomes in `t:failure/0`. With successful cleanup, callback exceptions retain their original reason and stack. Nested raising scopes propagate an inner failure through the outer scope while still attempting outer cleanup."},"source":{"line":84,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_scope-run_or_error-2"},{"id":"t:tmux_scope:exception/0","publicId":"t:tmux_scope:exception/0","qualifiedName":"tmux_scope:exception/0","name":"exception/0","namespace":"tmux_scope","parent":"tmux_scope","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type exception() ::\n          {exception,\n           error | exit | throw,\n           term(),\n           erlang:stacktrace()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":87,"end":91,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":106,"end":123,"target":"t:erlang:stacktrace/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"The original exception class, reason and stack, retained as evidence."},"source":{"line":16,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_scope-exception-0"},{"id":"t:tmux_scope:failure/0","publicId":"t:tmux_scope:failure/0","qualifiedName":"tmux_scope:failure/0","name":"failure/0","namespace":"tmux_scope","parent":"tmux_scope","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type failure() ::\n          #{code := scope_cleanup_failed,\n            primary := {ok, term()} | exception(),\n            cleanup := {error, term()} | exception(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":89,"end":93,"target":"t:erlang:term/0"},{"start":99,"end":108,"target":"t:tmux_scope:exception/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":143,"end":147,"target":"t:erlang:term/0"},{"start":153,"end":162,"target":"t:tmux_scope:exception/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":178,"end":182,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":188,"end":192,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Both outcomes when cleanup failed. primary contains the callback's ordinary return or exception; cleanup contains its separate error or exception. Resource-specific wrappers may add recovery handles to this map."},"source":{"line":22,"file":"apps/libtmux_erlang/src/tmux_scope.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_scope-failure-0"},{"id":"tmux_select","publicId":"tmux_select","qualifiedName":"tmux_select","name":"tmux_select","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Filter ordered captured rows without tmux I/O.","body":"Use `panes/1`, `windows/1`,\n`window_links/1` or `sessions/1` with a\n`m:tmux_snapshot` to retain graph coverage. `from_list/2`\npreserves supplied order, duplicates and row origins; it establishes only\nfields present in every row and loads no relationships. Filtering and\n`take/2` retain the original coverage even if no rows remain.\n\n`where/2` accepts map criteria or a `t:tmux_filter:t/0` portable\nfilter. `filter/2` accepts a unary Boolean function, whose\nexceptions propagate. Cardinality criteria validate the whole expression and\nits coverage before stopping at sufficient evidence. Selections are opaque\nvalues; use `to_list/1` for functions in `m:lists`.\n\nA snapshot-backed selection retains the complete captured graph, including\nrows removed by filtering. After relationship evaluation, store the result of\n`to_list/1` and release other snapshot and selection references to allow that\ncontext to be collected. Row extraction preserves the supplied field binaries;\ncaller-created subbinaries can still retain their backing allocation."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select"},{"id":"tmux_select:count/1","publicId":"tmux_select:count/1","qualifiedName":"tmux_select:count/1","name":"count/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"count(Selection)\n-spec count(t()) -> non_neg_integer().","references":[{"start":29,"end":30,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":37,"end":52,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the current materialized row count without I/O."},"source":{"line":290,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-count-1"},{"id":"tmux_select:count/2","publicId":"tmux_select:count/2","qualifiedName":"tmux_select:count/2","name":"count/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"count/2\n-spec count(criteria(), t()) -> non_neg_integer().","references":[{"start":20,"end":28,"target":"t:tmux_select:criteria/0"},{"start":32,"end":33,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":40,"end":55,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the exact local match count after full criteria and coverage validation. Performs no I/O."},"source":{"line":296,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-count-2"},{"id":"tmux_select:exists/1","publicId":"tmux_select:exists/1","qualifiedName":"tmux_select:exists/1","name":"exists/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"exists/1\n-spec exists(t()) -> boolean().","references":[{"start":22,"end":23,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":30,"end":37,"target":"t:erlang:boolean/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return whether this materialized selection is nonempty, without I/O."},"source":{"line":279,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-exists-1"},{"id":"tmux_select:exists/2","publicId":"tmux_select:exists/2","qualifiedName":"tmux_select:exists/2","name":"exists/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"exists(Criteria, Selection)\n-spec exists(criteria(), t()) -> boolean().","references":[{"start":41,"end":49,"target":"t:tmux_select:criteria/0"},{"start":53,"end":54,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":61,"end":68,"target":"t:erlang:boolean/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate all criteria/coverage first, then stop at the first local match. Performs no I/O; an empty selection does not bypass validation."},"source":{"line":285,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-exists-2"},{"id":"tmux_select:filter/2","publicId":"tmux_select:filter/2","qualifiedName":"tmux_select:filter/2","name":"filter/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"filter/2\n-spec filter(fun((Row) -> boolean()), t(Row)) -> t(Row)\n                when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":35,"end":42,"target":"t:erlang:boolean/0"},{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":58,"end":59,"target":"t:tmux_select:t/1"},{"start":93,"end":107,"target":"t:tmux_model:row/0"}],"params":[{"name":"Predicate","type":"fun((Row) -> boolean())","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":13,"end":20,"target":"t:erlang:boolean/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Apply an ordinary unary Boolean function locally, preserving row order and context. Non-Booleans and callback failures propagate; they are not false matches. This is executable application code, not portable filter data."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-filter-2"},{"id":"tmux_select:first/1","publicId":"tmux_select:first/1","qualifiedName":"tmux_select:first/1","name":"first/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"first/1\n-spec first(t(Row)) -> {ok, Row} | none\n               when Row :: tmux_model:row().","references":[{"start":20,"end":21,"target":"t:tmux_select:t/1"},{"start":75,"end":89,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | none","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the first current row or none. Additional matches are allowed. Performs no I/O."},"source":{"line":219,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-first-1"},{"id":"tmux_select:first/2","publicId":"tmux_select:first/2","qualifiedName":"tmux_select:first/2","name":"first/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"first(Criteria, Selection)\n-spec first(criteria(), t(Row)) -> {ok, Row} | none\n               when Row :: tmux_model:row().","references":[{"start":39,"end":47,"target":"t:tmux_select:criteria/0"},{"start":51,"end":52,"target":"t:tmux_select:t/1"},{"start":106,"end":120,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | none","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria and coverage, then stop at the first local match. Returns none when no row matches; performs no I/O."},"source":{"line":226,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-first-2"},{"id":"tmux_select:fold/3","publicId":"tmux_select:fold/3","qualifiedName":"tmux_select:fold/3","name":"fold/3","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"fold/3\n-spec fold(fun((Row, Acc) -> Acc), Acc, t(Row)) -> Acc\n              when Row :: tmux_model:row().","references":[{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":88,"end":102,"target":"t:tmux_model:row/0"}],"params":[{"name":"Function","type":"fun((Row, Acc) -> Acc)","typeReferences":[]},{"name":"Accumulator","type":"Acc","typeReferences":[]},{"name":"Argument3","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Acc","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Fold over current rows in order without I/O, using the function, accumulator, selection argument order. Arbitrary results are ordinary Erlang values."},"source":{"line":179,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-fold-3"},{"id":"tmux_select:from_list/2","publicId":"tmux_select:from_list/2","qualifiedName":"tmux_select:from_list/2","name":"from_list/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"from_list(Entity, Rows)\n-spec from_list(tmux_schema:entity(), [Row]) -> t(Row)\n                   when Row :: tmux_model:row().","references":[{"start":40,"end":58,"target":"t:tmux_schema:entity/0"},{"start":72,"end":73,"target":"t:tmux_select:t/1"},{"start":110,"end":124,"target":"t:tmux_model:row/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Rows","type":"[Row]","typeReferences":[]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate an ordinary list without rebinding, reordering or deduplicating it.","examples":[{"lang":"erlang","code":"1> {ok, P} = tmux_model:pane(#{id => <<\"%1\">>, width => 120}), ok.\nok\n2> S = tmux_select:from_list(pane, [P, P]), ok.\nok\n3> tmux_select:size(tmux_select:where(#{width => #{gte => 120}}, S)).\n2\n4> tmux_select:one(S).\n{error,{multiple_matches,#{at_least => 2}}}"}]},"source":{"line":99,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-from_list-2"},{"id":"tmux_select:matching/2","publicId":"tmux_select:matching/2","qualifiedName":"tmux_select:matching/2","name":"matching/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"matching/2\n-spec matching({module(), term()}, t(Row)) ->\n                  {ok, t(Row)} | {error, term()}\n                  when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:module/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:module/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":37,"end":41,"target":"t:erlang:term/0"},{"start":46,"end":47,"target":"t:tmux_select:t/1"},{"start":80,"end":81,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":98,"end":102,"target":"t:erlang:term/0"},{"start":136,"end":150,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"{module(), term()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:module/0","project":"Erlang/OTP"},"start":1,"end":7,"target":"t:erlang:module/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":11,"end":15,"target":"t:erlang:term/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, t(Row)} | {error, term()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":23,"end":27,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Prepare a trusted behaviour once, then apply its Boolean predicate.","body":"Uses `c:tmux_matcher:prepare/2`; preparation failure returns {error, Detail}.\nExceptions in either callback propagate. A matcher requires a captured\nsnapshot; a `from_list/2` selection returns matcher_requires_snapshot. The\napplication chooses Module."},"source":{"line":154,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-matching-2"},{"id":"tmux_select:one/1","publicId":"tmux_select:one/1","qualifiedName":"tmux_select:one/1","name":"one/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one/1\n-spec one(t(Row)) -> {ok, Row} | cardinality_error()\n             when Row :: tmux_model:row().","references":[{"start":16,"end":17,"target":"t:tmux_select:t/1"},{"start":39,"end":56,"target":"t:tmux_select:cardinality_error/0"},{"start":84,"end":98,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | cardinality_error()","returnsReferences":[{"start":12,"end":29,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole current row or a no_match/multiple_matches error. Ambiguity reports at_least = 2 rather than computing a needless exact count."},"source":{"line":233,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one-1"},{"id":"tmux_select:one/2","publicId":"tmux_select:one/2","qualifiedName":"tmux_select:one/2","name":"one/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one(Criteria, Selection)\n-spec one(criteria(), t(Row)) ->\n             {ok, Row} | cardinality_error()\n             when Row :: tmux_model:row().","references":[{"start":35,"end":43,"target":"t:tmux_select:criteria/0"},{"start":47,"end":48,"target":"t:tmux_select:t/1"},{"start":83,"end":100,"target":"t:tmux_select:cardinality_error/0"},{"start":128,"end":142,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row} | cardinality_error()","returnsReferences":[{"start":12,"end":29,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate criteria and coverage, then stop after enough local matches to establish cardinality. Returns a tagged cardinality result; performs no I/O."},"source":{"line":241,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one-2"},{"id":"tmux_select:one_or_error/1","publicId":"tmux_select:one_or_error/1","qualifiedName":"tmux_select:one_or_error/1","name":"one_or_error/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_error(Selection)\n-spec one_or_error(t(Row)) -> Row\n                      when Row :: tmux_model:row().","references":[{"start":43,"end":44,"target":"t:tmux_select:t/1"},{"start":92,"end":106,"target":"t:tmux_model:row/0"}],"params":[{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Row","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole row directly, raising on zero or multiple matches. Use `one/1` for tagged cardinality errors."},"source":{"line":262,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one_or_error-1"},{"id":"tmux_select:one_or_error/2","publicId":"tmux_select:one_or_error/2","qualifiedName":"tmux_select:one_or_error/2","name":"one_or_error/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_error(Criteria, Selection)\n-spec one_or_error(criteria(), t(Row)) -> Row\n                      when Row :: tmux_model:row().","references":[{"start":53,"end":61,"target":"t:tmux_select:criteria/0"},{"start":65,"end":66,"target":"t:tmux_select:t/1"},{"start":114,"end":128,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"Row","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Filter locally with complete validation, then return the sole row directly. Raises on zero or multiple matches; performs no I/O."},"source":{"line":273,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one_or_error-2"},{"id":"tmux_select:one_or_none/1","publicId":"tmux_select:one_or_none/1","qualifiedName":"tmux_select:one_or_none/1","name":"one_or_none/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_none(Selection)\n-spec one_or_none(t(Row)) ->\n                     {ok, Row | none} | cardinality_error()\n                     when Row :: tmux_model:row().","references":[{"start":41,"end":42,"target":"t:tmux_select:t/1"},{"start":92,"end":109,"target":"t:tmux_select:cardinality_error/0"},{"start":145,"end":159,"target":"t:tmux_model:row/0"}],"params":[{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row | none} | cardinality_error()","returnsReferences":[{"start":19,"end":36,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the sole current row, {ok, none} on absence, or a multiple-match error. Performs no I/O."},"source":{"line":248,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one_or_none-1"},{"id":"tmux_select:one_or_none/2","publicId":"tmux_select:one_or_none/2","qualifiedName":"tmux_select:one_or_none/2","name":"one_or_none/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"one_or_none(Criteria, Selection)\n-spec one_or_none(criteria(), t(Row)) ->\n                     {ok, Row | none} | cardinality_error()\n                     when Row :: tmux_model:row().","references":[{"start":51,"end":59,"target":"t:tmux_select:criteria/0"},{"start":63,"end":64,"target":"t:tmux_select:t/1"},{"start":114,"end":131,"target":"t:tmux_select:cardinality_error/0"},{"start":167,"end":181,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, Row | none} | cardinality_error()","returnsReferences":[{"start":19,"end":36,"target":"t:tmux_select:cardinality_error/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate local criteria and return one row or known absence. A second match is an explicit ambiguity error; performs no I/O."},"source":{"line":255,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-one_or_none-2"},{"id":"tmux_select:panes/1","publicId":"tmux_select:panes/1","qualifiedName":"tmux_select:panes/1","name":"panes/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Snapshot)\n-spec panes(tmux_snapshot:t()) -> t(tmux_model:pane()).","references":[{"start":28,"end":43,"target":"t:tmux_snapshot:t/0"},{"start":50,"end":51,"target":"t:tmux_select:t/1"},{"start":52,"end":67,"target":"t:tmux_model:pane/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:pane())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":17,"target":"t:tmux_model:pane/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select captured physical panes while retaining snapshot graph and coverage. Performs no I/O and preserves the snapshot's deterministic order."},"source":{"line":64,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-panes-1"},{"id":"tmux_select:sessions/1","publicId":"tmux_select:sessions/1","qualifiedName":"tmux_select:sessions/1","name":"sessions/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Snapshot)\n-spec sessions(tmux_snapshot:t()) ->\n                  t(tmux_model:session()).","references":[{"start":34,"end":49,"target":"t:tmux_snapshot:t/0"},{"start":74,"end":75,"target":"t:tmux_select:t/1"},{"start":76,"end":94,"target":"t:tmux_model:session/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:session())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":20,"target":"t:tmux_model:session/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select captured sessions with their relationship and coverage context. Performs no I/O."},"source":{"line":82,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-sessions-1"},{"id":"tmux_select:size/1","publicId":"tmux_select:size/1","qualifiedName":"tmux_select:size/1","name":"size/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"size/1\n-spec size(t()) -> non_neg_integer().","references":[{"start":18,"end":19,"target":"t:tmux_select:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":26,"end":41,"target":"t:erlang:non_neg_integer/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"non_neg_integer()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the cached number of materialized rows in this selection without traversing tmux or re-evaluating criteria."},"source":{"line":192,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-size-1"},{"id":"tmux_select:summary/1","publicId":"tmux_select:summary/1","qualifiedName":"tmux_select:summary/1","name":"summary/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"summary/1\n-spec summary(t()) -> summary().","references":[{"start":24,"end":25,"target":"t:tmux_select:t/0"},{"start":32,"end":39,"target":"t:tmux_select:summary/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/0"}]}],"returns":"summary()","returnsReferences":[{"start":0,"end":7,"target":"t:tmux_select:summary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a compact Erlang diagnostic map with entity, size, capture identity, interval and coverage. Fetched queries include candidate/attempt information. Opaque snapshot references make this a diagnostic value, not a wire format."},"source":{"line":200,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-summary-1"},{"id":"tmux_select:take/2","publicId":"tmux_select:take/2","qualifiedName":"tmux_select:take/2","name":"take/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"take/2\n-spec take(non_neg_integer(), t(Row)) -> t(Row)\n              when Row :: tmux_model:row().","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":18,"end":33,"target":"t:erlang:non_neg_integer/0"},{"start":37,"end":38,"target":"t:tmux_select:t/1"},{"start":48,"end":49,"target":"t:tmux_select:t/1"},{"start":81,"end":95,"target":"t:tmux_model:row/0"}],"params":[{"name":"Count","type":"non_neg_integer()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":0,"end":15,"target":"t:erlang:non_neg_integer/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Keep the first N rows and retain the original observation and coverage. Performs no I/O; taking a subset cannot establish missing field coverage."},"source":{"line":185,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-take-2"},{"id":"tmux_select:to_list/1","publicId":"tmux_select:to_list/1","qualifiedName":"tmux_select:to_list/1","name":"to_list/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"to_list/1\n-spec to_list(t(Row)) -> [Row] when Row :: tmux_model:row().","references":[{"start":24,"end":25,"target":"t:tmux_select:t/1"},{"start":53,"end":67,"target":"t:tmux_model:row/0"}],"params":[{"name":"Argument1","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"[Row]","returnsReferences":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the current ordered rows as an ordinary Erlang list without I/O. Use list functions or comprehensions for transformations to other value types. Returns the stored rows without copying their binary fields. Keeping only the list allows the selection's snapshot context to be collected; other references can still keep that context alive."},"source":{"line":173,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-to_list-1"},{"id":"tmux_select:try_where/2","publicId":"tmux_select:try_where/2","qualifiedName":"tmux_select:try_where/2","name":"try_where/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"try_where/2\n-spec try_where(criteria(), t(Row)) ->\n                   {ok, t(Row)} | {error, map()}\n                   when Row :: tmux_model:row().","references":[{"start":28,"end":36,"target":"t:tmux_select:criteria/0"},{"start":40,"end":41,"target":"t:tmux_select:t/1"},{"start":75,"end":76,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"start":131,"end":145,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"{ok, t(Row)} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_select:t/1"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":23,"end":26,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Apply the same local criteria and coverage checks as `where/2`, returning tagged validation or evaluation errors. It does not catch arbitrary application callback exceptions and never performs tmux I/O."},"source":{"line":129,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-try_where-2"},{"id":"tmux_select:where/2","publicId":"tmux_select:where/2","qualifiedName":"tmux_select:where/2","name":"where/2","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"where(Criteria, Selection)\n-spec where(criteria(), t(Row)) -> t(Row)\n               when Row :: tmux_model:row().","references":[{"start":39,"end":47,"target":"t:tmux_select:criteria/0"},{"start":51,"end":52,"target":"t:tmux_select:t/1"},{"start":62,"end":63,"target":"t:tmux_select:t/1"},{"start":96,"end":110,"target":"t:tmux_model:row/0"}],"params":[{"name":"Criteria","type":"criteria()","typeReferences":[{"start":0,"end":8,"target":"t:tmux_select:criteria/0"}]},{"name":"Selection","type":"t(Row)","typeReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"returns":"t(Row)","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Validate portable criteria and coverage, then preserve matching rows in order. Performs no I/O. Malformed trusted criteria raise bad_filter; missing coverage and runtime evaluation failures remain distinct exceptions. Use `try_where/2` for tagged library errors."},"source":{"line":117,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-where-2"},{"id":"tmux_select:window_links/1","publicId":"tmux_select:window_links/1","qualifiedName":"tmux_select:window_links/1","name":"window_links/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Snapshot)\n-spec window_links(tmux_snapshot:t()) ->\n                      t(tmux_model:window_link()).","references":[{"start":42,"end":57,"target":"t:tmux_snapshot:t/0"},{"start":86,"end":87,"target":"t:tmux_select:t/1"},{"start":88,"end":110,"target":"t:tmux_model:window_link/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:window_link())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":24,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select all captured session memberships, retaining repeated physical windows and session-relative indexes. Performs no I/O."},"source":{"line":76,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-window_links-1"},{"id":"tmux_select:windows/1","publicId":"tmux_select:windows/1","qualifiedName":"tmux_select:windows/1","name":"windows/1","namespace":"tmux_select","parent":"tmux_select","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Snapshot)\n-spec windows(tmux_snapshot:t()) -> t(tmux_model:window()).","references":[{"start":32,"end":47,"target":"t:tmux_snapshot:t/0"},{"start":54,"end":55,"target":"t:tmux_select:t/1"},{"start":56,"end":73,"target":"t:tmux_model:window/0"}],"params":[{"name":"Snapshot","type":"tmux_snapshot:t()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_snapshot:t/0"}]}],"returns":"t(tmux_model:window())","returnsReferences":[{"start":0,"end":1,"target":"t:tmux_select:t/1"},{"start":2,"end":19,"target":"t:tmux_model:window/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select unique captured physical windows with their complete graph context. Performs no I/O; session memberships remain separate window-link rows."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_select-windows-1"},{"id":"t:tmux_select:cardinality_error/0","publicId":"t:tmux_select:cardinality_error/0","qualifiedName":"tmux_select:cardinality_error/0","name":"cardinality_error/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type cardinality_error() ::\n          {error,\n           no_match | {multiple_matches, #{at_least := 2}}}.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"supporting","source":{"line":47,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_select-cardinality_error-0"},{"id":"t:tmux_select:criteria/0","publicId":"t:tmux_select:criteria/0","qualifiedName":"tmux_select:criteria/0","name":"criteria/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type criteria() :: map() | tmux_filter:t().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"},{"start":28,"end":41,"target":"t:tmux_filter:t/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"supporting","source":{"line":46,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_select-criteria-0"},{"id":"t:tmux_select:summary/0","publicId":"t:tmux_select:summary/0","qualifiedName":"tmux_select:summary/0","name":"summary/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type summary() ::\n          #{entity := tmux_schema:entity(),\n            size := non_neg_integer(),\n            snapshot_id := reference() | none,\n            coverage := tmux_snapshot:entity_coverage(),\n            capture_started => integer(),\n            capture_finished => integer(),\n            time_unit => microsecond,\n            query => tmux_snapshot:query_metadata()}.","params":[],"references":[{"start":41,"end":59,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":83,"end":98,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":129,"end":138,"target":"t:erlang:reference/0"},{"start":173,"end":202,"target":"t:tmux_snapshot:entity_coverage/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":237,"end":244,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":280,"end":287,"target":"t:erlang:integer/0"},{"start":350,"end":378,"target":"t:tmux_snapshot:query_metadata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Compact local inspection. size counts current materialized rows; coverage still describes the original captured context after filtering or take. snapshot_id is none for a list-backed selection. Capture bounds and query diagnostics are included only when that source metadata exists."},"source":{"line":54,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_select-summary-0"},{"id":"t:tmux_select:t/0","publicId":"t:tmux_select:t/0","qualifiedName":"tmux_select:t/0","name":"t/0","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type t() :: t(tmux_model:row()).","params":[],"references":[{"start":13,"end":14,"target":"t:tmux_select:t/1"},{"start":15,"end":29,"target":"t:tmux_model:row/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A selection over schema-defined native domain records."},"source":{"line":45,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_select-t-0"},{"id":"t:tmux_select:t/1","publicId":"t:tmux_select:t/1","qualifiedName":"tmux_select:t/1","name":"t/1","namespace":"tmux_select","parent":"tmux_select","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t(Row).","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Ordered captured rows with observation and coverage context, not an extensible list protocol. The parameter describes the intended row type. OTP 29 Dialyzer can widen generic return variables to their declared bounds; it does not prove every entity relationship through `one/1` or `to_list/1`. Runtime schema, coverage and action checks remain necessary."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_select.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_select-t-1"},{"id":"tmux_server","publicId":"tmux_server","qualifiedName":"tmux_server","name":"tmux_server","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Open tmux endpoints and execute explicit command values.","body":"`open/1` validates an absolute socket path and the\nexecutable/server versions. It never creates a tmux server or attaches a\ncontrol client. Each command rechecks the observed Linux process incarnation\nbefore dispatch. Replacement between that observation and a later client\nconnection remains possible; same_connection requests are rejected until\npersistent dispatch qualifies.\n\n`start_owned/1` creates a separate private daemon and returns an ownership\ntoken for `stop_owned/1`. The [ownership guide](ownership.md) explains caller\ndeath, application shutdown and namespace cleanup.\n\nUse `with_server/2` or `with_owned/2` for a callback scope. They attempt cleanup\nafter its return or exception and preserve both outcomes if cleanup fails.\n\nThe calling process owns the endpoint. `close/1` cancels queued\nwork, retires its one-shot clients and preserves the borrowed server. Cleanup\nfailure remains explicit and keeps the supervised owner alive. Successful close is\nidempotent during the 60-second handle retention period. Separate\n`m:tmux_control` attachments receive an invalidation notice and begin their\nown retirement. Close those attachments explicitly to prove their native\ncleanup. Command results preserve stdout, stderr and status; cancellation\nafter dispatch cannot undo\nremote effects. Clients explicitly select tmux's UTF-8 mode so Unicode and the\nidentity probe's tab do not depend on the caller's locale. Command-specific\nescaping still applies to raw command output.\n\nUse `snapshot/1` to capture a graph for `m:tmux_snapshot` and\n`m:tmux_select`. Use `m:tmux_operation` for non-blocking submission and\nexplicit waits; the [job guide](jobs.md) explains ownership and cleanup."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server"},{"id":"tmux_server:bind/2","publicId":"tmux_server:bind/2","qualifiedName":"tmux_server:bind/2","name":"bind/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"bind(Server, Row)\n-spec bind(t(), tmux_model:row()) ->\n              {ok, tmux_model:row()} | {error, map()}.","references":[{"start":29,"end":30,"target":"t:tmux_server:t/0"},{"start":34,"end":48,"target":"t:tmux_model:row/0"},{"start":74,"end":88,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":102,"end":105,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]}],"returns":"{ok, tmux_model:row()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicitly read current fields from this server and register the new value. For sessions, physical windows and panes, the read uses the stable ID and discards the supplied field observations. This explicit call accepts an edited target; ordinary actions require its captured target association to match and reject mismatches before dispatch. The returned row carries a new private observation association; see `m:tmux_model`. It provides no atomic identity check. Window-link binding checks its session/index and expected physical window. A replaced or missing membership returns stale_link. This observed preflight does not make a later action atomic.","body":"Invalid rows are rejected before I/O:","examples":[{"lang":"erlang","code":"1> tmux_server:bind(invalid_server, invalid_row).\n{error,#{code => invalid_row,path => []}}"}]},"source":{"line":350,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-bind-2"},{"id":"tmux_server:close/1","publicId":"tmux_server:close/1","qualifiedName":"tmux_server:close/1","name":"close/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"close(Server)\n-spec close(t()) -> ok | {error, map()}.","references":[{"start":26,"end":27,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":47,"end":50,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Retire this endpoint's operations and one-shot clients, preserving the borrowed tmux server. Returns ok only after their cleanup completes; incomplete cleanup remains an explicit error. Closing an already closed retained handle is idempotent. The initiator controls endpoint lifetime. Separate control attachments are invalidated and asked to retire; use `tmux_control:close/1` before this call to verify those clients' cleanup too."},"source":{"line":267,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-close-1"},{"id":"tmux_server:command/3","publicId":"tmux_server:command/3","qualifiedName":"tmux_server:command/3","name":"command/3","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"command(Server, Command, Options)\n-spec command(t(), tmux_command:t(), command_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":48,"end":49,"target":"t:tmux_server:t/0"},{"start":53,"end":67,"target":"t:tmux_command:t/0"},{"start":71,"end":86,"target":"t:tmux_server:command_options/0"},{"start":115,"end":139,"target":"t:tmux_operation:completed/0"},{"start":170,"end":192,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Command","type":"tmux_command:t()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_command:t/0"}]},{"name":"Options","type":"command_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_server:command_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Execute one validated command and await its result. Performs I/O. The result preserves stdout, stderr, exit status and cleanup certainty. Use `tmux_operation:start/3` to submit without blocking this caller. A timeout or cancellation cannot reverse effects that may already have reached tmux. Values from domain command builders keep their captured endpoint origin. Another endpoint returns different_owner with submitted = false before any native preflight or execution. Raw commands do not carry that origin."},"source":{"line":252,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-command-3"},{"id":"tmux_server:open/1","publicId":"tmux_server:open/1","qualifiedName":"tmux_server:open/1","name":"open/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"open(Options)\n-spec open(open_options()) -> {ok, t()} | {error, map()}.","references":[{"start":25,"end":37,"target":"t:tmux_server:open_options/0"},{"start":49,"end":50,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":64,"end":67,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"open_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_server:open_options/0"}]}],"returns":"{ok, t()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":20,"end":23,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Open a borrowed socket endpoint and start its supervised library owner. The caller owns that handle. This probes the executable, daemon version and observed Linux process incarnation; it never starts a tmux server or attaches a control client. Pass an absolute socket_path and optionally an executable."},"source":{"line":114,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-open-1"},{"id":"tmux_server:origin/1","publicId":"tmux_server:origin/1","qualifiedName":"tmux_server:origin/1","name":"origin/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"origin(Server)\n-spec origin(t()) -> {ok, reference()} | {error, map()}.","references":[{"start":28,"end":29,"target":"t:tmux_server:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":41,"end":50,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":64,"end":67,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, reference()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":5,"end":14,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":28,"end":31,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the registered opaque origin for this open endpoint. The token provides library provenance and generation checks, not authorization against trusted Erlang code. It is not a portable identifier."},"source":{"line":282,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-origin-1"},{"id":"tmux_server:snapshot/1","publicId":"tmux_server:snapshot/1","qualifiedName":"tmux_server:snapshot/1","name":"snapshot/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot(Server)\n-spec snapshot(t()) ->\n                  {ok, tmux_snapshot:t()} | {error, map()}.","references":[{"start":32,"end":33,"target":"t:tmux_server:t/0"},{"start":63,"end":78,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":92,"end":95,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, tmux_snapshot:t()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture a complete immutable graph with default capture limits. Performs I/O. See `snapshot/2` for bounds, consistency and conflict errors."},"source":{"line":297,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-snapshot-1"},{"id":"tmux_server:snapshot/2","publicId":"tmux_server:snapshot/2","qualifiedName":"tmux_server:snapshot/2","name":"snapshot/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"snapshot(Server, Options)\n-spec snapshot(t(), capture_options()) ->\n                  {ok, tmux_snapshot:t()} | {error, map()}.","references":[{"start":41,"end":42,"target":"t:tmux_server:t/0"},{"start":46,"end":61,"target":"t:tmux_server:capture_options/0"},{"start":91,"end":106,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":120,"end":123,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"capture_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_server:capture_options/0"}]}],"returns":"{ok, tmux_snapshot:t()} | {error, map()}","returnsReferences":[{"start":5,"end":20,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":34,"end":37,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture the server's sessions, physical windows, window links and panes.","body":"This performs explicit I/O and records each command's observation interval.\nIdentity scans bracket field reads; detected topology or value disagreements\nreturn inconsistent_capture. Changes between reads can remain undetected,\nincluding changes followed by a reversal. Atomic capture is unsupported.\n\nOptions are consistency (observed only), deadline_ms (default 2500, maximum\n600000), max_rows (4096, maximum 65536 raw observations per scan and aggregate\nspine) and max_bytes (8 MiB, maximum 64 MiB total stdout across capture\ncommands). Repeated memberships count before deduplication. The\n`t:hydration/0` strategy defaults to batched. Each command is limited to 1 MiB;\nisolated hydration distributes larger entity output across individual fields.\nThese are data limits, not a VM heap limit. Capturing performs no retry. Local\nreads of the resulting value do no I/O. `tmux_snapshot:metadata/1` records the\nstrategy and actual source calls.\n\nUnsupported consistency is rejected before contacting a server:","examples":[{"lang":"erlang","code":"1> tmux_server:snapshot(invalid_server, #{consistency => atomic}).\n{error,#{code => unsupported_consistency}}"}]},"source":{"line":325,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-snapshot-2"},{"id":"tmux_server:start_owned/1","publicId":"tmux_server:start_owned/1","qualifiedName":"tmux_server:start_owned/1","name":"start_owned/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"start_owned(Options)\n-spec start_owned(owned_options()) ->\n                     {ok, t(), ownership()} |\n                     {error, map()}.","references":[{"start":39,"end":52,"target":"t:tmux_server:owned_options/0"},{"start":85,"end":86,"target":"t:tmux_server:t/0"},{"start":90,"end":99,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":134,"end":137,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"owned_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:owned_options/0"}]}],"returns":"{ok, t(), ownership()} | {error, map()}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"},{"start":10,"end":19,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Start an empty owned daemon in a fresh private Linux socket directory. Performs I/O and waits for bounded startup; no session or attached observer is created. Returns an ordinary endpoint and a separate `t:ownership/0` token. The caller owns the daemon lifetime: caller death or `stop_owned/1` retires its helper tree. `close/1` only closes the endpoint and preserves the daemon.","body":"The daemon starts without a user config, with `exit-empty` disabled. One idle,\nunattached bootstrap client keeps the owned helper tree alive. Startup includes\nreadiness and endpoint incarnation binding, not just executable launch.\nIncomplete cleanup remains explicit; it is never permission to kill by path.\nAn incomplete startup error includes an ownership token and captured resources\nfor `stop_owned/1` recovery. The token does not serialize across VM lifetimes."},"source":{"line":142,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-start_owned-1"},{"id":"tmux_server:status/1","publicId":"tmux_server:status/1","qualifiedName":"tmux_server:status/1","name":"status/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"status(Server)\n-spec status(t()) ->\n                {ok, state()} |\n                {error, tmux_operation:failure()}.","references":[{"start":28,"end":29,"target":"t:tmux_server:t/0"},{"start":57,"end":62,"target":"t:tmux_server:state/0"},{"start":92,"end":114,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, state()} | {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":10,"target":"t:tmux_server:state/0"},{"start":24,"end":46,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read the endpoint owner's lifecycle and resource summary. This contacts the library owner, not tmux, and does not refresh captured rows."},"source":{"line":274,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-status-1"},{"id":"tmux_server:stop_owned/1","publicId":"tmux_server:stop_owned/1","qualifiedName":"tmux_server:stop_owned/1","name":"stop_owned/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"stop_owned(Ownership)\n-spec stop_owned(ownership()) -> ok | {error, map()}.","references":[{"start":39,"end":48,"target":"t:tmux_server:ownership/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":68,"end":71,"target":"t:erlang:map/0"}],"params":[{"name":"Ownership","type":"ownership()","typeReferences":[{"start":0,"end":9,"target":"t:tmux_server:ownership/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Stop the daemon and endpoint associated with a `t:ownership/0` token. Performs I/O and returns ok only after endpoint/client/helper retirement and namespace cleanup are proved. It never sends kill-server to a socket path.","body":"A replaced socket/directory or unexpected directory contents are preserved and\nreturn `cleanup_incomplete` with process and namespace details. A supervised\ntombstone retains uncertain cleanup; call again to inspect/retry after external\nrepair. Filesystem identity checks are observations, not atomic reservations\nagainst another trusted process replacing a path during unlink.\n\nSuccessful stop is idempotent during the 60-second token retention period.\nAfter token expiry or application shutdown, returns `ownership_expired`.\nStop explicitly before application shutdown when the caller needs a verified\ncleanup result. OTP application shutdown itself does not prove native cleanup.\nIncomplete shutdown writes a private recovery report outside the owned socket\ndirectory and logs its location or write failure; no automatic recovery runs."},"source":{"line":163,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-stop_owned-1"},{"id":"tmux_server:version/1","publicId":"tmux_server:version/1","qualifiedName":"tmux_server:version/1","name":"version/1","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"version(Server)\n-spec version(t()) ->\n                 {ok, tmux_version:t()} | {error, map()}.","references":[{"start":30,"end":31,"target":"t:tmux_server:t/0"},{"start":60,"end":74,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":88,"end":91,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, tmux_version:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return the daemon version observed when the endpoint opened. This reads owner state and does not execute a fresh version command or qualify another tmux release."},"source":{"line":290,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-version-1"},{"id":"tmux_server:with_owned/2","publicId":"tmux_server:with_owned/2","qualifiedName":"tmux_server:with_owned/2","name":"with_owned/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"with_owned(Options, Function)\n-spec with_owned(owned_options(), fun((t()) -> Value)) ->\n                    {ok, Value} |\n                    {error, scope_failure() | map()}.","references":[{"start":47,"end":60,"target":"t:tmux_server:owned_options/0"},{"start":69,"end":70,"target":"t:tmux_server:t/0"},{"start":150,"end":163,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":168,"end":171,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"owned_options()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:owned_options/0"}]},{"name":"Function","type":"fun((t()) -> Value)","typeReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, Value} | {error, scope_failure() | map()}","returnsReferences":[{"start":22,"end":35,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Start an owned daemon, run a callback in the calling process, then stop it. Performs `start_owned/1` and token-based `stop_owned/1` around the callback. With successful cleanup, returns {ok, Value} or re-raises the original callback exception. A returned error tuple is an ordinary callback value. Startup failure passes through without invoking the callback.","body":"Cleanup failure returns `t:scope_failure/0`, including both server and ownership\nhandles for inspection and an explicit stop retry. It preserves the callback\noutcome and cleanup evidence separately; it never claims timeout is retirement.\nSee `with_server/2` for callback and separately allocated resource obligations."},"source":{"line":204,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-with_owned-2"},{"id":"tmux_server:with_server/2","publicId":"tmux_server:with_server/2","qualifiedName":"tmux_server:with_server/2","name":"with_server/2","namespace":"tmux_server","parent":"tmux_server","kind":"function","modifiers":[],"signatures":[{"raw":"with_server(Options, Function)\n-spec with_server(open_options(), fun((t()) -> Value)) ->\n                     {ok, Value} |\n                     {error, scope_failure() | map()}.","references":[{"start":49,"end":61,"target":"t:tmux_server:open_options/0"},{"start":70,"end":71,"target":"t:tmux_server:t/0"},{"start":153,"end":166,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":171,"end":174,"target":"t:erlang:map/0"}],"params":[{"name":"Options","type":"open_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_server:open_options/0"}]},{"name":"Function","type":"fun((t()) -> Value)","typeReferences":[{"start":5,"end":6,"target":"t:tmux_server:t/0"}]}],"returns":"{ok, Value} | {error, scope_failure() | map()}","returnsReferences":[{"start":22,"end":35,"target":"t:tmux_server:scope_failure/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Open a borrowed endpoint, run a callback in the calling process, then close it. Performs the same I/O as `open/1` and `close/1`; the borrowed daemon survives. Startup failure passes through without invoking the callback.","body":"With successful cleanup, returns {ok, Value} for any callback return value,\nincluding a returned error tuple. Callback error, throw and exit exceptions\nare re-raised with their original reason and stack. If cleanup fails, returns\n{error, Failure} with `t:scope_failure/0`, preserving both outcomes and the\nendpoint for explicit recovery. It attempts cleanup once; a timeout does not\nprove retirement. Existing supervised cleanup ownership remains in force.\n\nThe callback must retire separately created resources such as `m:tmux_control`\nattachments. This scope closes its endpoint, not every resource the callback\nmay allocate. Use `with_owned/2` when the scope should own the daemon too."},"source":{"line":183,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_server-with_server-2"},{"id":"t:tmux_server:capture_options/0","publicId":"t:tmux_server:capture_options/0","qualifiedName":"tmux_server:capture_options/0","name":"capture_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type capture_options() ::\n          #{deadline_ms => 1..600000,\n            max_rows => 1..65536,\n            max_bytes => 1..67108864,\n            hydration => hydration(),\n            consistency => observed | atomic}.","params":[],"references":[{"start":162,"end":171,"target":"t:tmux_server:hydration/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture bounds, hydration strategy and consistency request. Atomic capture is unsupported."},"source":{"line":85,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-capture_options-0"},{"id":"t:tmux_server:command_options/0","publicId":"t:tmux_server:command_options/0","qualifiedName":"tmux_server:command_options/0","name":"command_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type command_options() ::\n          #{deadline_ms => 1..600000,\n            max_stdout => 0..1048576,\n            max_stderr => 0..65536,\n            stdin => binary(),\n            identity => observed | same_connection}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Command options: deadline_ms defaults to 2500, max_stdout to 1 MiB, max_stderr to 64 KiB, stdin to an empty binary and identity to observed. The deadline includes admission, preflight and execution. stdin is limited to 256 KiB; stdin plus the rendered argument reservation must also fit 256 KiB. Each endpoint admits at most 64 operations and 256 KiB of command payload; exhaustion returns busy. same_connection is recognized but unsupported."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-command_options-0"},{"id":"t:tmux_server:hydration/0","publicId":"t:tmux_server:hydration/0","qualifiedName":"tmux_server:hydration/0","name":"hydration/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type hydration() :: batched | isolated.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture text/bytes with one framed scan per entity (batched, the default), or one field per physical row (isolated). Both retain complete graph coverage and interval semantics. Each command has the same 1 MiB stdout bound; isolated can distribute large entity output across commands at greater source cost. See `snapshot/2` and `tmux_query:explain/1`."},"source":{"line":83,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-hydration-0"},{"id":"t:tmux_server:open_options/0","publicId":"t:tmux_server:open_options/0","qualifiedName":"tmux_server:open_options/0","name":"open_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type open_options() ::\n          #{socket_path := binary(),\n            executable => binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":51,"end":57,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":87,"end":93,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An explicit absolute socket endpoint and optional absolute tmux executable path."},"source":{"line":58,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-open_options-0"},{"id":"t:tmux_server:owned_options/0","publicId":"t:tmux_server:owned_options/0","qualifiedName":"tmux_server:owned_options/0","name":"owned_options/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type owned_options() ::\n          #{executable => binary(),\n            startup_timeout_ms => 1..600000}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":51,"end":57,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Owned startup options. The finite startup budget defaults to 2500 milliseconds."},"source":{"line":60,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-owned_options-0"},{"id":"t:tmux_server:ownership/0","publicId":"t:tmux_server:ownership/0","qualifiedName":"tmux_server:ownership/0","name":"ownership/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque ownership().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Opaque ownership token for `stop_owned/1`. An ordinary endpoint or row origin does not convey this token. Trusted code can pass it to another process."},"source":{"line":65,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-ownership-0"},{"id":"t:tmux_server:scope_failure/0","publicId":"t:tmux_server:scope_failure/0","qualifiedName":"tmux_server:scope_failure/0","name":"scope_failure/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type scope_failure() ::\n          #{code := scope_cleanup_failed,\n            primary :=\n                {ok, term()} |\n                {exception,\n                 error | exit | throw,\n                 term(),\n                 erlang:stacktrace()},\n            cleanup :=\n                {error, map()} |\n                {exception,\n                 error | exit | throw,\n                 term(),\n                 erlang:stacktrace()},\n            server := t(),\n            ownership => ownership()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":111,"end":115,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":205,"end":209,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":230,"end":247,"target":"t:erlang:stacktrace/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":299,"end":302,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":392,"end":396,"target":"t:erlang:term/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:stacktrace/0","project":"Erlang/OTP"},"start":417,"end":434,"target":"t:erlang:stacktrace/0"},{"start":461,"end":462,"target":"t:tmux_server:t/0"},{"start":491,"end":500,"target":"t:tmux_server:ownership/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Both callback and cleanup evidence when a scope cannot prove retirement. primary is the callback value or its exception class, reason and original stack. cleanup preserves the operational error or a separate cleanup exception. server permits `close/1` reconciliation; owned scopes also include ownership for `stop_owned/1`. Retain these handles until cleanup is resolved."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-scope_failure-0"},{"id":"t:tmux_server:state/0","publicId":"t:tmux_server:state/0","qualifiedName":"tmux_server:state/0","name":"state/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type state() ::\n          #{phase := open | closing | closed,\n            generation := reference(),\n            owner := pid(),\n            operations := non_neg_integer(),\n            command_bytes := non_neg_integer(),\n            active_bytes := non_neg_integer(),\n            retained_results := non_neg_integer(),\n            result_bytes := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":89,"end":98,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:pid/0","project":"Erlang/OTP"},"start":123,"end":126,"target":"t:erlang:pid/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":156,"end":171,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":204,"end":219,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":251,"end":266,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":302,"end":317,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":349,"end":364,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Endpoint resource summary. owner is the supervised endpoint process, not its initiating caller. operations and command_bytes count active admission leases; active_bytes reserves output capacity. Retired results are bounded separately by retained_results and result_bytes. These are accounting limits, not VM heap measurements. generation identifies this endpoint handle's lifetime."},"source":{"line":94,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-state-0"},{"id":"t:tmux_server:t/0","publicId":"t:tmux_server:t/0","qualifiedName":"tmux_server:t/0","name":"t/0","namespace":"tmux_server","parent":"tmux_server","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A supervised borrowed-endpoint handle bound to an owner generation and admission state."},"source":{"line":103,"file":"apps/libtmux_erlang/src/tmux_server.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_server-t-0"},{"id":"tmux_session","publicId":"tmux_session","qualifiedName":"tmux_session","name":"tmux_session","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create and observe sessions, or act on a session's registered stable ID.","body":"`create/2` accepts name, window_name, width, height, cwd, env,\nlaunch and detach. Creation defaults to detached with tmux's configured\nshell/command. launch is default_shell, an argv map, or an explicit shell map.\nenv augments tmux's inherited environment. tmux supplies PATH, SHELL, PWD and\nTMUX_PANE after that merge, so those entries may be replaced. Names and cwd\nare literal format values; tmux's stored name rules still apply. Creation\nnever adopts an existing session by name.\n\nAn empty shell command can exit immediately and remove its session. It does\nnot request the empty-pane behavior of split-window. Use a running program\nwhen later operations require the session to remain alive.\n\n`create/2` and `get/2` explicitly read the\nnew/current row through several one-shot commands. These reads are not atomic.\nIf creation succeeds but observation fails, the error retains mutation =\ncompleted and the original command result. `rename/2` and\n`kill/1` return command results without refreshing the input\nrecord. Detached rows require `tmux_server:bind/2` before actions.\n`rename_command/2` builds a reusable value without tmux I/O; the other calls\nperform I/O after validation.\n\n`select/2` switches one explicitly named attached client to a session. It\nnever attaches a client or infers the current client. Use\n`tmux_window_link:select/1` to select a session's window membership instead."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session"},{"id":"tmux_session:create/2","publicId":"tmux_session:create/2","qualifiedName":"tmux_session:create/2","name":"create/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"create(Server, Options)\n-spec create(tmux_server:t(), create_options()) ->\n                {ok, tmux_model:session()} | {error, map()}.","references":[{"start":37,"end":50,"target":"t:tmux_server:t/0"},{"start":54,"end":68,"target":"t:tmux_session:create_options/0"},{"start":96,"end":114,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":128,"end":131,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Options","type":"create_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_session:create_options/0"}]}],"returns":"{ok, tmux_model:session()} | {error, map()}","returnsReferences":[{"start":5,"end":23,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":37,"end":40,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Create a detached session by default and explicitly observe the returned row. Options include name, window_name, dimensions, cwd, env and launch. Performs I/O; an observation failure after successful creation retains mutation = completed and the original command result. Existing names are not adopted."},"source":{"line":48,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-create-2"},{"id":"tmux_session:get/2","publicId":"tmux_session:get/2","qualifiedName":"tmux_session:get/2","name":"get/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:session_id()) ->\n             {ok, tmux_model:session()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":64,"target":"t:tmux_model:session_id/0"},{"start":89,"end":107,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":121,"end":124,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:session_id()","typeReferences":[{"start":0,"end":21,"target":"t:tmux_model:session_id/0"}]}],"returns":"{ok, tmux_model:session()} | {error, map()}","returnsReferences":[{"start":5,"end":23,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":37,"end":40,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read fresh session fields through explicit one-shot commands. The session ID is stable within the observed server incarnation. Returns target_gone when tmux no longer has that session; it never refreshes an existing record."},"source":{"line":64,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-get-2"},{"id":"tmux_session:kill/1","publicId":"tmux_session:kill/1","qualifiedName":"tmux_session:kill/1","name":"kill/1","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Session)\n-spec kill(tmux_model:session()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":25,"end":43,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":69,"end":72,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":86,"end":89,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy this registered session. Performs I/O and returns the command result; this is a destructive session action, not endpoint cleanup. References must belong to a live registered owner."},"source":{"line":170,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-kill-1"},{"id":"tmux_session:rename/2","publicId":"tmux_session:rename/2","qualifiedName":"tmux_session:rename/2","name":"rename/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Session, Name)\n-spec rename(tmux_model:session(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":35,"end":53,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":57,"end":63,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":91,"end":94,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":108,"end":111,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename the registered session using a literal name and return the command result. Performs I/O. Previously captured records keep their old names; detached or stale references fail validation before the action."},"source":{"line":72,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-rename-2"},{"id":"tmux_session:rename_command/2","publicId":"tmux_session:rename_command/2","qualifiedName":"tmux_session:rename_command/2","name":"rename_command/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"rename_command(Session, Name)\n-spec rename_command(tmux_model:session(), binary()) ->\n                        {ok, tmux_command:t()} |\n                        {error, map()}.","references":[{"start":51,"end":69,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":73,"end":79,"target":"t:erlang:binary/0"},{"start":115,"end":129,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":167,"end":170,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, tmux_command:t()} | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_command:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":33,"end":36,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Build a literal rename command without tmux I/O. Validates the row and keeps its captured origin; endpoint liveness is checked during execution. Submit the value to `tmux_server:command/3` or `tmux_operation:start/3` with its original endpoint. Existing session records retain their captured name.","body":"Detached rows require `tmux_server:bind/2` first. Building a command does not\nexecute it or make a repeated mutation safe.","examples":[{"lang":"erlang","code":"1> tmux_session:rename_command(invalid_row, <<\"work\">>).\n{error,#{code => invalid_row,path => []}}"}]},"source":{"line":93,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-rename_command-2"},{"id":"tmux_session:select/2","publicId":"tmux_session:select/2","qualifiedName":"tmux_session:select/2","name":"select/2","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"select(Session, Client)\n-spec select(tmux_model:session(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":37,"end":55,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":59,"end":65,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":93,"end":96,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":110,"end":113,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Client","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Switch an explicitly named attached client to this registered session, preserving the session environment. Performs I/O. See `select/3` for client lookup, environment updates and disconnection races.","body":"An empty client name cannot select an implicit current client:","examples":[{"lang":"erlang","code":"1> tmux_session:select(invalid_session, <<>>).\n{error,#{code => invalid_client,path => [client]}}"}]},"source":{"line":113,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-select-2"},{"id":"tmux_session:select/3","publicId":"tmux_session:select/3","qualifiedName":"tmux_session:select/3","name":"select/3","namespace":"tmux_session","parent":"tmux_session","kind":"function","modifiers":[],"signatures":[{"raw":"select(Session, Client, Options)\n-spec select(tmux_model:session(),\n             binary(),\n             select_options()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":46,"end":64,"target":"t:tmux_model:session/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":81,"end":87,"target":"t:erlang:binary/0"},{"start":104,"end":118,"target":"t:tmux_session:select_options/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":146,"end":149,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":163,"end":166,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Client","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]},{"name":"Options","type":"select_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_session:select_options/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Switch one attached client, selected by its literal native client name or TTY path, to the session's registered stable ID. Performs I/O and returns the command result; existing rows remain captured values. Obtain the name from the caller's own client context, such as tmux's `client_name` format. There is no default client and this call never attaches one.","body":"`update_environment` defaults to false (`switch-client -E`). When true, tmux\nupdates the destination session environment using its `update-environment`\noption and that client's environment; listed variables absent from the client\ncan be marked for removal. Running pane processes retain their environment.\n\nNames are nonempty NUL-free binaries of at most 32 KiB. Trailing-colon aliases\nare rejected. Native lookup matches an exact name or TTY path, including its\n`/dev/`-relative alias; there is no prefix or pattern matching. A disconnected\nname returns `client_not_found`. Names and TTY paths can be reused by a later\nconnection; this API does not identify a client incarnation atomically. A\nmissing destination returns `target_gone`. See `tmux_server:bind/2` for detached\nsession rows and `tmux_window_link:select/1` for window selection."},"source":{"line":137,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_session-select-3"},{"id":"t:tmux_session:create_options/0","publicId":"t:tmux_session:create_options/0","qualifiedName":"tmux_session:create_options/0","name":"create_options/0","namespace":"tmux_session","parent":"tmux_session","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type create_options() ::\n          #{name => binary(),\n            window_name => binary(),\n            width => 1..65535,\n            height => 1..65535,\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":83,"end":89,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":175,"end":181,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":206,"end":212,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":218,"end":224,"target":"t:erlang:binary/0"},{"start":251,"end":275,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":301,"end":308,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Session creation options. Launch defaults to the configured shell; creation defaults to detached."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_session-create_options-0"},{"id":"t:tmux_session:select_options/0","publicId":"t:tmux_session:select_options/0","qualifiedName":"tmux_session:select_options/0","name":"select_options/0","namespace":"tmux_session","parent":"tmux_session","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type select_options() ::\n          #{update_environment => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":60,"end":67,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Session selection options. update_environment defaults to false, preserving the destination environment."},"source":{"line":39,"file":"apps/libtmux_erlang/src/tmux_session.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_session-select_options-0"},{"id":"tmux_snapshot","publicId":"tmux_snapshot","qualifiedName":"tmux_snapshot","name":"tmux_snapshot","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Read an immutable captured graph without performing tmux I/O.","body":"Server-wide lists use numeric ID order. Window links retain every membership,\nincluding multiple indexes for the same window in one session. Session windows\nare unique in first-link order; panes within a window use pane index order.\n`related/3` accepts a row from this snapshot and returns a\ntagged result. A row from another observation cannot silently select a\nrelationship in this one.\n\n`metadata/1` records source calls, the capture interval,\nendpoint generation and the observed server incarnation. Captures span\ncommands and are not atomic. Values remain readable after their endpoint\ncloses; actions still validate the row's registered origin. Coverage\ndistinguishes unloaded data from an empty collection and unavailable fields\nfrom known absence. See the [graph guide](graph.md) for physical windows and\nsession memberships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot"},{"id":"tmux_snapshot:coverage/1","publicId":"tmux_snapshot:coverage/1","qualifiedName":"tmux_snapshot:coverage/1","name":"coverage/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"coverage/1\n-spec coverage(t()) -> coverage().","references":[{"start":26,"end":27,"target":"t:tmux_snapshot:t/0"},{"start":34,"end":42,"target":"t:tmux_snapshot:coverage/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"coverage()","returnsReferences":[{"start":0,"end":8,"target":"t:tmux_snapshot:coverage/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return per-collection, field and relationship coverage. Loaded values, known absence, not_loaded and unavailable capabilities have distinct meanings. Performs no I/O."},"source":{"line":181,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-coverage-1"},{"id":"tmux_snapshot:get/3","publicId":"tmux_snapshot:get/3","qualifiedName":"tmux_snapshot:get/3","name":"get/3","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"get/3\n-spec get(tmux_schema:entity(), term(), t()) ->\n             {ok, tmux_model:row()} | none | {error, map()}.","references":[{"start":16,"end":34,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":38,"end":42,"target":"t:erlang:term/0"},{"start":46,"end":47,"target":"t:tmux_snapshot:t/0"},{"start":72,"end":86,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":107,"end":110,"target":"t:erlang:map/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Key","type":"term()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:term/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok, tmux_model:row()} | none | {error, map()}","returnsReferences":[{"start":5,"end":19,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":40,"end":43,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Look up a row in this capture by ID, or a session/index/window tuple for a window link. Returns none for a known missing identity and a tagged coverage error for an unloaded collection. Performs no I/O."},"source":{"line":132,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-get-3"},{"id":"tmux_snapshot:metadata/1","publicId":"tmux_snapshot:metadata/1","qualifiedName":"tmux_snapshot:metadata/1","name":"metadata/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"metadata/1\n-spec metadata(t()) -> metadata().","references":[{"start":26,"end":27,"target":"t:tmux_snapshot:t/0"},{"start":34,"end":42,"target":"t:tmux_snapshot:metadata/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"metadata()","returnsReferences":[{"start":0,"end":8,"target":"t:tmux_snapshot:metadata/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return capture identity, server generation, source calls, capabilities and read interval metadata. Does not refresh the graph or imply atomic capture."},"source":{"line":174,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-metadata-1"},{"id":"tmux_snapshot:panes/1","publicId":"tmux_snapshot:panes/1","qualifiedName":"tmux_snapshot:panes/1","name":"panes/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"panes(Snapshot)\n-spec panes(t()) -> [tmux_model:pane()].","references":[{"start":28,"end":29,"target":"t:tmux_snapshot:t/0"},{"start":37,"end":52,"target":"t:tmux_model:pane/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:pane()]","returnsReferences":[{"start":1,"end":16,"target":"t:tmux_model:pane/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return unique captured physical panes in numeric ID order without I/O. `related/3` orders panes within a window by pane index."},"source":{"line":111,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-panes-1"},{"id":"tmux_snapshot:related/3","publicId":"tmux_snapshot:related/3","qualifiedName":"tmux_snapshot:related/3","name":"related/3","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"related/3\n-spec related(atom(), tmux_model:row(), t()) ->\n                 {ok,\n                  [tmux_model:row()] |\n                  tmux_model:row() |\n                  none} |\n                 {error, map()}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":24,"end":28,"target":"t:erlang:atom/0"},{"start":32,"end":46,"target":"t:tmux_model:row/0"},{"start":50,"end":51,"target":"t:tmux_snapshot:t/0"},{"start":99,"end":113,"target":"t:tmux_model:row/0"},{"start":137,"end":151,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":207,"end":210,"target":"t:erlang:map/0"}],"params":[{"name":"Relation","type":"atom()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":0,"end":4,"target":"t:erlang:atom/0"}]},{"name":"Row","type":"tmux_model:row()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_model:row/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"{ok,\n           [tmux_model:row()] | tmux_model:row() | none} |\n          {error, map()}","returnsReferences":[{"start":17,"end":31,"target":"t:tmux_model:row/0"},{"start":37,"end":51,"target":"t:tmux_model:row/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":82,"end":85,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Traverse a complete captured relationship without I/O. To-many relations return lists; to-one relations return a row or known absence. The input row must belong to this snapshot. Unloaded relations and mismatched rows return tagged errors."},"source":{"line":149,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-related-3"},{"id":"tmux_snapshot:require/2","publicId":"tmux_snapshot:require/2","qualifiedName":"tmux_snapshot:require/2","name":"require/2","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"require/2\n-spec require([requirement()], t()) -> ok | {error, map()}.","references":[{"start":25,"end":36,"target":"t:tmux_snapshot:requirement/0"},{"start":41,"end":42,"target":"t:tmux_snapshot:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":62,"end":65,"target":"t:erlang:map/0"}],"params":[{"name":"Requirements","type":"[requirement()]","typeReferences":[{"start":1,"end":12,"target":"t:tmux_snapshot:requirement/0"}]},{"name":"Argument2","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"ok | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":13,"end":16,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Check every declared collection/field/relationship requirement before local evaluation. Returns an incomplete_snapshot error with missing requirements when the capture cannot answer faithfully. Performs no I/O, even on empty data."},"source":{"line":190,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-require-2"},{"id":"tmux_snapshot:rows/2","publicId":"tmux_snapshot:rows/2","qualifiedName":"tmux_snapshot:rows/2","name":"rows/2","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"rows/2\n-spec rows(tmux_schema:entity(), t()) -> [tmux_model:row()].","references":[{"start":18,"end":36,"target":"t:tmux_schema:entity/0"},{"start":40,"end":41,"target":"t:tmux_snapshot:t/0"},{"start":49,"end":63,"target":"t:tmux_model:row/0"}],"params":[{"name":"Entity","type":"tmux_schema:entity()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_schema:entity/0"}]},{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:row()]","returnsReferences":[{"start":1,"end":15,"target":"t:tmux_model:row/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return a captured collection by schema entity. Performs no I/O. An unloaded collection raises incomplete_snapshot rather than appearing empty."},"source":{"line":118,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-rows-2"},{"id":"tmux_snapshot:sessions/1","publicId":"tmux_snapshot:sessions/1","qualifiedName":"tmux_snapshot:sessions/1","name":"sessions/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"sessions(Snapshot)\n-spec sessions(t()) -> [tmux_model:session()].","references":[{"start":34,"end":35,"target":"t:tmux_snapshot:t/0"},{"start":43,"end":61,"target":"t:tmux_model:session/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:session()]","returnsReferences":[{"start":1,"end":19,"target":"t:tmux_model:session/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return captured sessions in numeric ID order. Performs no I/O and raises incomplete_snapshot when that collection was not captured."},"source":{"line":92,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-sessions-1"},{"id":"tmux_snapshot:window_links/1","publicId":"tmux_snapshot:window_links/1","qualifiedName":"tmux_snapshot:window_links/1","name":"window_links/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"window_links(Snapshot)\n-spec window_links(t()) -> [tmux_model:window_link()].","references":[{"start":42,"end":43,"target":"t:tmux_snapshot:t/0"},{"start":51,"end":73,"target":"t:tmux_model:window_link/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:window_link()]","returnsReferences":[{"start":1,"end":23,"target":"t:tmux_model:window_link/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return every captured membership, ordered by numeric session ID, index and window ID. Multiple links to the same physical window are preserved. Performs no I/O; link identity belongs to this snapshot."},"source":{"line":105,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-window_links-1"},{"id":"tmux_snapshot:windows/1","publicId":"tmux_snapshot:windows/1","qualifiedName":"tmux_snapshot:windows/1","name":"windows/1","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"function","modifiers":[],"signatures":[{"raw":"windows(Snapshot)\n-spec windows(t()) -> [tmux_model:window()].","references":[{"start":32,"end":33,"target":"t:tmux_snapshot:t/0"},{"start":41,"end":58,"target":"t:tmux_model:window/0"}],"params":[{"name":"Snapshot","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_snapshot:t/0"}]}],"returns":"[tmux_model:window()]","returnsReferences":[{"start":1,"end":18,"target":"t:tmux_model:window/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Return unique captured physical windows in numeric ID order. Performs no I/O. Use `window_links/1` for session-relative membership and indexes."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_snapshot-windows-1"},{"id":"t:tmux_snapshot:coverage/0","publicId":"t:tmux_snapshot:coverage/0","qualifiedName":"tmux_snapshot:coverage/0","name":"coverage/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type coverage() ::\n          #{tmux_schema:entity() => entity_coverage()}.","params":[],"references":[{"start":32,"end":50,"target":"t:tmux_schema:entity/0"},{"start":56,"end":71,"target":"t:tmux_snapshot:entity_coverage/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Per-entity coverage. Use `require/2` to check requirements before evaluation."},"source":{"line":53,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-coverage-0"},{"id":"t:tmux_snapshot:entity_coverage/0","publicId":"t:tmux_snapshot:entity_coverage/0","qualifiedName":"tmux_snapshot:entity_coverage/0","name":"entity_coverage/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type entity_coverage() ::\n          #{collection := complete | not_loaded,\n            fields :=\n                #{atom() =>\n                      loaded | not_loaded | unavailable},\n            relations :=\n                #{atom() => complete | not_loaded}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":116,"end":120,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":227,"end":231,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Collection completeness, field availability and relationship completeness. A loaded field can hold a known value or known absence; inspect the row to distinguish them. not_loaded never means empty, and unavailable never means known absence. Completeness is relative to the captured source collection."},"source":{"line":49,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-entity_coverage-0"},{"id":"t:tmux_snapshot:metadata/0","publicId":"t:tmux_snapshot:metadata/0","qualifiedName":"tmux_snapshot:metadata/0","name":"metadata/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type metadata() ::\n          #{id := reference(),\n            origin := reference(),\n            model_version := 2,\n            graph := complete | partial,\n            generation => reference(),\n            endpoint => #{socket_path := binary()},\n            server_instance => tmux_identity:t(),\n            tmux_version => tmux_version:t(),\n            capture_started => integer(),\n            capture_finished => integer(),\n            time_unit => microsecond,\n            source_calls => [source_call()],\n            observed_bytes => non_neg_integer(),\n            consistency => observed,\n            hydration => tmux_server:hydration(),\n            capabilities =>\n                #{field_schema := 1,\n                  identity := observed,\n                  capture := observed},\n            query => query_metadata(),\n            atom() => term()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":38,"end":47,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":73,"end":82,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:reference/0","project":"Erlang/OTP"},"start":185,"end":194,"target":"t:erlang:reference/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":239,"end":245,"target":"t:erlang:binary/0"},{"start":281,"end":296,"target":"t:tmux_identity:t/0"},{"start":328,"end":342,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":377,"end":384,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":420,"end":427,"target":"t:erlang:integer/0"},{"start":498,"end":509,"target":"t:tmux_snapshot:source_call/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":544,"end":559,"target":"t:erlang:non_neg_integer/0"},{"start":625,"end":646,"target":"t:tmux_server:hydration/0"},{"start":816,"end":830,"target":"t:tmux_snapshot:query_metadata/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":846,"end":850,"target":"t:erlang:atom/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":856,"end":860,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Capture identity and provenance. id identifies this snapshot, origin its registered endpoint and generation the endpoint lifetime. model_version names the row representation. graph describes relationship coverage, not atomicity.","body":"Live captures include endpoint, observed server_instance, tmux_version,\nmonotonic capture bounds in time_unit, source_calls, observed stdout bytes and\ncapabilities. Those fields can be absent in internally constructed partial\ncaptures. Query captures also include `t:query_metadata/0`. Opaque references\nand process identities are local values, not portable wire identifiers.\nhydration records the requested `t:tmux_server:hydration/0` strategy; source_calls\nshows which commands actually ran, including any schema-driven fallback."},"source":{"line":77,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-metadata-0"},{"id":"t:tmux_snapshot:query_metadata/0","publicId":"t:tmux_snapshot:query_metadata/0","qualifiedName":"tmux_snapshot:query_metadata/0","name":"query_metadata/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type query_metadata() ::\n          #{candidate_count := non_neg_integer(),\n            pushed_down := boolean(),\n            attempt := 1 | 2,\n            consistency := observed}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":57,"end":72,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":103,"end":110,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Source-query capture diagnostics. candidate_count is the deduplicated candidate identity count before local residuals and limits. pushed_down records a nontrivial native condition in the plan, not proof that its command ran: empty collections can skip it. source_calls records actual capture commands. The flag does not mean the full predicate was translated. attempt starts at one and increases only for an explicitly requested retry."},"source":{"line":62,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-query_metadata-0"},{"id":"t:tmux_snapshot:requirement/0","publicId":"t:tmux_snapshot:requirement/0","qualifiedName":"tmux_snapshot:requirement/0","name":"requirement/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type requirement() ::\n          {collection, tmux_schema:entity()} |\n          {field | relation, tmux_schema:entity(), atom()}.","params":[],"references":[{"start":46,"end":64,"target":"t:tmux_schema:entity/0"},{"start":99,"end":117,"target":"t:tmux_schema:entity/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:atom/0","project":"Erlang/OTP"},"start":121,"end":125,"target":"t:erlang:atom/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A collection, field or complete relationship needed for faithful local evaluation."},"source":{"line":34,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-requirement-0"},{"id":"t:tmux_snapshot:source_call/0","publicId":"t:tmux_snapshot:source_call/0","qualifiedName":"tmux_snapshot:source_call/0","name":"source_call/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type source_call() ::\n          #{command := binary(),\n            args := [binary()],\n            started := integer(),\n            finished := integer(),\n            stdout_bytes := non_neg_integer()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":77,"end":83,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":111,"end":118,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:integer/0","project":"Erlang/OTP"},"start":146,"end":153,"target":"t:erlang:integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":185,"end":200,"target":"t:erlang:non_neg_integer/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"One completed capture command and its stdout byte count. started and finished are local monotonic microseconds, not wall-clock timestamps. The interval includes identity preflight and command completion; it is not an atomic read."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-source_call-0"},{"id":"t:tmux_snapshot:t/0","publicId":"t:tmux_snapshot:t/0","qualifiedName":"tmux_snapshot:t/0","name":"t/0","namespace":"tmux_snapshot","parent":"tmux_snapshot","kind":"typealias","modifiers":["opaque"],"signatures":[{"raw":"-opaque t().","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An immutable captured graph with identity, indexes, coverage and source intervals."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_snapshot.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_snapshot-t-0"},{"id":"tmux_version","publicId":"tmux_version","qualifiedName":"tmux_version","name":"tmux_version","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Parse the output of tmux -V without invoking tmux.","body":"Support covers tmux 3.3a through 3.8, including intermediate releases. The\nminimum-version check includes the patch letter; numeric feature comparisons\nuse major/minor components. CI tests the endpoints of the supported range. Use\n`tmux_server:version/1` for the daemon version observed by an endpoint."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_version"},{"id":"tmux_version:at_least/2","publicId":"tmux_version:at_least/2","qualifiedName":"tmux_version:at_least/2","name":"at_least/2","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"at_least/2\n-spec at_least(t(),\n               {non_neg_integer(), non_neg_integer()}) ->\n                  boolean().","references":[{"start":26,"end":27,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":47,"end":62,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":66,"end":81,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":107,"end":114,"target":"t:erlang:boolean/0"}],"params":[{"name":"Argument1","type":"t()","typeReferences":[{"start":0,"end":1,"target":"t:tmux_version:t/0"}]},{"name":"Argument2","type":"{non_neg_integer(), non_neg_integer()}","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":1,"end":16,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":20,"end":35,"target":"t:erlang:non_neg_integer/0"}]}],"returns":"boolean()","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":0,"end":7,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Compare numeric major/minor components with a required floor. Patch letters do not promote an older minor release. Performs no I/O."},"source":{"line":73,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_version-at_least-2"},{"id":"tmux_version:parse/1","publicId":"tmux_version:parse/1","qualifiedName":"tmux_version:parse/1","name":"parse/1","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"parse/1\n-spec parse(binary()) ->\n               {ok, t()} |\n               {error, {invalid_tmux_version, term()}}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":20,"end":26,"target":"t:erlang:binary/0"},{"start":53,"end":54,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":106,"end":110,"target":"t:erlang:term/0"}],"params":[{"name":"Raw","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} |\n          {error, {invalid_tmux_version, term()}}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":53,"end":57,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Parse bounded tmux -V output into numeric components and patch/tracking metadata. This is pure parsing, not a probe or compatibility qualification."},"source":{"line":25,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_version-parse-1"},{"id":"tmux_version:require/1","publicId":"tmux_version:require/1","qualifiedName":"tmux_version:require/1","name":"require/1","namespace":"tmux_version","parent":"tmux_version","kind":"function","modifiers":[],"signatures":[{"raw":"require(Raw)\n-spec require(binary()) ->\n                 {ok, t()} |\n                 {error,\n                  {invalid_tmux_version |\n                   unsupported_tmux_version,\n                   term()}}.","references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":27,"end":33,"target":"t:erlang:binary/0"},{"start":62,"end":63,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":200,"end":204,"target":"t:erlang:term/0"}],"params":[{"name":"Raw","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, t()} |\n          {error,\n           {invalid_tmux_version | unsupported_tmux_version,\n            term()}}","returnsReferences":[{"start":5,"end":6,"target":"t:tmux_version:t/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:term/0","project":"Erlang/OTP"},"start":103,"end":107,"target":"t:erlang:term/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Reject a tmux release below the supported floor.","examples":[{"lang":"erlang","code":"1> {ok, Version} = tmux_version:require(<<\"tmux 3.3a\">>), ok.\nok\n2> tmux_version:at_least(Version, {3, 4}).\nfalse"}]},"source":{"line":58,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_version-require-1"},{"id":"t:tmux_version:t/0","publicId":"t:tmux_version:t/0","qualifiedName":"tmux_version:t/0","name":"t/0","namespace":"tmux_version","parent":"tmux_version","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type t() ::\n          #{major := non_neg_integer(),\n            minor := non_neg_integer(),\n            patch := binary(),\n            tracking := boolean(),\n            raw := binary()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":34,"end":49,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:non_neg_integer/0","project":"Erlang/OTP"},"start":74,"end":89,"target":"t:erlang:non_neg_integer/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":114,"end":120,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":148,"end":155,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":178,"end":184,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Parsed numeric daemon version plus patch, tracking and original-output metadata."},"source":{"line":17,"file":"apps/libtmux_erlang/src/tmux_version.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_version-t-0"},{"id":"tmux_window","publicId":"tmux_window","qualifiedName":"tmux_window","name":"tmux_window","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Create physical windows in a session and act through their registered IDs.","body":"`create/2` accepts name, cwd, env, launch and detach, using the\nsession's next available index. It defaults to detached. `get/2`\nreads current fields; `rename/2` returns the command result and\nleaves previous records unchanged. Launch and environment options follow\n`tmux_session:create/2`. An empty shell command does not portably keep the\nwindow alive: older tmux releases execute it as a shell command. Use a running\nprogram when needed. Creation returns a fresh observed row or an error\nretaining a completed mutation and its result if the follow-up observation\nfails.\n\n`kill/1` destroys the physical window and all its links. Use\n`tmux_window_link:unlink/2` to remove one session membership. These calls\nperform I/O after validating their inputs. `select_layout/2`\nchanges the physical window's layout across all its session links; previously\nobserved pane geometry remains unchanged in captured values."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window"},{"id":"tmux_window:create/2","publicId":"tmux_window:create/2","qualifiedName":"tmux_window:create/2","name":"create/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"create(Session, Options)\n-spec create(tmux_model:session(), create_options()) ->\n                {ok, tmux_model:window()} | {error, map()}.","references":[{"start":38,"end":56,"target":"t:tmux_model:session/0"},{"start":60,"end":74,"target":"t:tmux_window:create_options/0"},{"start":102,"end":119,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":133,"end":136,"target":"t:erlang:map/0"}],"params":[{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"create_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_window:create_options/0"}]}],"returns":"{ok, tmux_model:window()} | {error, map()}","returnsReferences":[{"start":5,"end":22,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Create a physical window in the session's next free index and observe it. Defaults to detached. Launch, cwd and environment follow `tmux_session:create/2`. Performs I/O and retains completed-mutation details if observation fails."},"source":{"line":41,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-create-2"},{"id":"tmux_window:get/2","publicId":"tmux_window:get/2","qualifiedName":"tmux_window:get/2","name":"get/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, Id)\n-spec get(tmux_server:t(), tmux_model:window_id()) ->\n             {ok, tmux_model:window()} | {error, map()}.","references":[{"start":26,"end":39,"target":"t:tmux_server:t/0"},{"start":43,"end":63,"target":"t:tmux_model:window_id/0"},{"start":88,"end":105,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":119,"end":122,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"Id","type":"tmux_model:window_id()","typeReferences":[{"start":0,"end":20,"target":"t:tmux_model:window_id/0"}]}],"returns":"{ok, tmux_model:window()} | {error, map()}","returnsReferences":[{"start":5,"end":22,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":36,"end":39,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Explicitly read a physical window by stable ID. Returns a fresh record or target_gone. Physical windows do not have a universal session or window index."},"source":{"line":56,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-get-2"},{"id":"tmux_window:kill/1","publicId":"tmux_window:kill/1","qualifiedName":"tmux_window:kill/1","name":"kill/1","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"kill(Window)\n-spec kill(tmux_model:window()) ->\n              {ok, map()} | {error, map()}.","references":[{"start":24,"end":41,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":67,"end":70,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":84,"end":87,"target":"t:erlang:map/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destroy the physical window and all of its session links. This does not unlink only one membership. Performs I/O after origin and target validation."},"source":{"line":74,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-kill-1"},{"id":"tmux_window:rename/2","publicId":"tmux_window:rename/2","qualifiedName":"tmux_window:rename/2","name":"rename/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"rename(Window, Name)\n-spec rename(tmux_model:window(), binary()) ->\n                {ok, map()} | {error, map()}.","references":[{"start":34,"end":51,"target":"t:tmux_model:window/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":55,"end":61,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":89,"end":92,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":106,"end":109,"target":"t:erlang:map/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Name","type":"binary()","typeReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":0,"end":6,"target":"t:erlang:binary/0"}]}],"returns":"{ok, map()} | {error, map()}","returnsReferences":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":5,"end":8,"target":"t:erlang:map/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":22,"end":25,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Rename the registered physical window with a literal name. Performs I/O and returns the command result. Captured rows and snapshots remain unchanged."},"source":{"line":63,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-rename-2"},{"id":"tmux_window:respawn/2","publicId":"tmux_window:respawn/2","qualifiedName":"tmux_window:respawn/2","name":"respawn/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"respawn(Window, Options)\n-spec respawn(tmux_model:window(), respawn_options()) ->\n                 {ok, tmux_operation:completed()} |\n                 {error, tmux_operation:failure()}.","references":[{"start":39,"end":56,"target":"t:tmux_model:window/0"},{"start":60,"end":75,"target":"t:tmux_window:respawn_options/0"},{"start":104,"end":128,"target":"t:tmux_operation:completed/0"},{"start":159,"end":181,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Options","type":"respawn_options()","typeReferences":[{"start":0,"end":15,"target":"t:tmux_window:respawn_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Respawn a registered physical window across all its session links. tmux keeps the first pane's ID, removes the other panes and rebuilds a single-pane layout. force defaults false: a window with a running pane normally returns command_error. force = true permits closing existing PTYs. Command completion does not establish former-job termination or application readiness. Other panes can already be removed if a later spawn step fails. Respawn also selects this window in tmux's resolved session. For a window linked into several sessions, tmux chooses that context from the physical ID; this facade does not pin selection or environment to a captured membership.","body":"launch defaults to previous and reuses the retained pane's saved command.\nExplicit argv and shell maps, saved cwd and fresh-spawn environment rules\nfollow `tmux_pane:respawn/2`, using the resolved session's environment. This\nphysical-window mutation affects every link. Performs I/O after validation and\nreturns the command result without refreshing rows. Use `get/2` or a new\nsnapshot for current data."},"source":{"line":96,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-respawn-2"},{"id":"tmux_window:select_layout/2","publicId":"tmux_window:select_layout/2","qualifiedName":"tmux_window:select_layout/2","name":"select_layout/2","namespace":"tmux_window","parent":"tmux_window","kind":"function","modifiers":[],"signatures":[{"raw":"select_layout(Window, Layout)\n-spec select_layout(tmux_model:window(), layout()) ->\n                       {ok, tmux_operation:completed()} |\n                       {error, tmux_operation:failure()}.","references":[{"start":50,"end":67,"target":"t:tmux_model:window/0"},{"start":71,"end":77,"target":"t:tmux_window:layout/0"},{"start":112,"end":136,"target":"t:tmux_operation:completed/0"},{"start":173,"end":195,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Window","type":"tmux_model:window()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_model:window/0"}]},{"name":"Layout","type":"layout()","typeReferences":[{"start":0,"end":6,"target":"t:tmux_window:layout/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select a built-in arrangement or restore a literal serialized layout for this registered physical window. Binary names must exactly match one of the five built-ins; abbreviations and other names are rejected. Legacy serialized layouts need four hexadecimal checksum digits, a comma and nonempty data. This guard avoids a malformed-header crash in tmux 3.3 and 3.3a.","body":"Native JSON v2 layouts require a bounded JSON object with V = 2 and an L\nobject. They return unsupported_capability on tmux before 3.8 without\ndispatching a tmux command. This preserves `get/2` layout restoration on newer\nservers.\n\nExecution unzooms the window and changes it in every linked session. tmux\nvalidates serialized geometry; malformed geometry can return a command error.\nThe layout argument uses no shell or format expansion. Existing rows are not\nrefreshed; use `get/2` or a fresh snapshot to observe layout and pane\ngeometry.\n\nUnsupported atom names fail before dispatch:","examples":[{"lang":"erlang","code":"1> tmux_window:select_layout(invalid_row, unknown_layout).\n{error,#{code => invalid_layout,path => [layout]}}"}]},"source":{"line":131,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window-select_layout-2"},{"id":"t:tmux_window:create_options/0","publicId":"t:tmux_window:create_options/0","qualifiedName":"tmux_window:create_options/0","name":"create_options/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type create_options() ::\n          #{name => binary(),\n            cwd => binary(),\n            env => #{binary() => binary()},\n            launch => tmux_command:launch_spec(),\n            detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":46,"end":52,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":75,"end":81,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":106,"end":112,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":118,"end":124,"target":"t:erlang:binary/0"},{"start":151,"end":175,"target":"t:tmux_command:launch_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":201,"end":208,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Physical-window creation options; defaults to a detached window at the next free session index."},"source":{"line":25,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window-create_options-0"},{"id":"t:tmux_window:layout/0","publicId":"t:tmux_window:layout/0","qualifiedName":"tmux_window:layout/0","name":"layout/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type layout() ::\n          even_horizontal | even_vertical |\n          main_horizontal | main_vertical | tiled |\n          binary().","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":124,"end":130,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"A built-in arrangement, its exact binary name, or a serialized layout. Native JSON v2 requires tmux 3.8."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window-layout-0"},{"id":"t:tmux_window:respawn_options/0","publicId":"t:tmux_window:respawn_options/0","qualifiedName":"tmux_window:respawn_options/0","name":"respawn_options/0","namespace":"tmux_window","parent":"tmux_window","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type respawn_options() ::\n          #{force => boolean(),\n            launch => tmux_command:respawn_spec(),\n            cwd => binary(),\n            env => #{binary() => binary()}}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":48,"end":55,"target":"t:erlang:boolean/0"},{"start":81,"end":106,"target":"t:tmux_command:respawn_spec/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":129,"end":135,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":160,"end":166,"target":"t:erlang:binary/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:binary/0","project":"Erlang/OTP"},"start":172,"end":178,"target":"t:erlang:binary/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Physical-window respawn options. Defaults: force false, launch previous, saved cwd. A forced respawn removes other panes."},"source":{"line":28,"file":"apps/libtmux_erlang/src/tmux_window.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window-respawn_options-0"},{"id":"tmux_window_link","publicId":"tmux_window_link","qualifiedName":"tmux_window_link","name":"tmux_window_link","kind":"module","modifiers":[],"signatures":[],"apiScope":"exported","package":"libtmux_erlang","product":"core","doc":{"summary":"Act on a physical window's observed membership in a particular session.","body":"A window link is identified by session ID, window index and expected physical\nwindow ID. It has no stable tmux link ID. These calls check that the observed\nmembership still names the expected window before dispatching an action.\nMissing or replaced membership returns stale_link. A link that moves away and\nback to the same coordinates and physical window cannot be distinguished.\n\nThe preflight and action use separate one-shot commands. Concurrent changes\nafter preflight can still affect the action; this is not atomic\ncompare-and-act. All input rows must belong to the same registered owner.\nRe-read or explicitly bind rows when using another owner. Closed owners and\nknown restarts invalidate their rows. Every call performs explicit I/O after\nvalidating its arguments.\n\nUse `tmux_window:kill/1` to destroy a physical window across all memberships.\nUse `unlink/2` to remove one membership. Existing rows and\nsnapshots are never refreshed by actions; use `get/3` or a\nnew snapshot for current memberships."},"source":{"line":1,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link"},{"id":"tmux_window_link:get/3","publicId":"tmux_window_link:get/3","qualifiedName":"tmux_window_link:get/3","name":"get/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"get(Server, SessionId, Index)\n-spec get(tmux_server:t(),\n          tmux_model:session_id(),\n          index()) ->\n             {ok, tmux_model:window_link()} |\n             {error, map()}.","references":[{"start":40,"end":53,"target":"t:tmux_server:t/0"},{"start":67,"end":88,"target":"t:tmux_model:session_id/0"},{"start":102,"end":107,"target":"t:tmux_window_link:index/0"},{"start":132,"end":154,"target":"t:tmux_model:window_link/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":181,"end":184,"target":"t:erlang:map/0"}],"params":[{"name":"Server","type":"tmux_server:t()","typeReferences":[{"start":0,"end":13,"target":"t:tmux_server:t/0"}]},{"name":"SessionId","type":"tmux_model:session_id()","typeReferences":[{"start":0,"end":21,"target":"t:tmux_model:session_id/0"}]},{"name":"Index","type":"index()","typeReferences":[{"start":0,"end":5,"target":"t:tmux_window_link:index/0"}]}],"returns":"{ok, tmux_model:window_link()} | {error, map()}","returnsReferences":[{"start":5,"end":27,"target":"t:tmux_model:window_link/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:map/0","project":"Erlang/OTP"},"start":41,"end":44,"target":"t:erlang:map/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Read a current membership at the explicit session ID and index. The returned native row carries its registered owner and a new observation identity. Returns target_gone if the session or index is absent. This read does not make later actions atomic and does not refresh previously captured links.","body":"Invalid indexes are rejected before I/O:","examples":[{"lang":"erlang","code":"1> tmux_window_link:get(invalid_server, <<\"$0\">>, -1).\n{error,#{code => invalid_option,path => [index]}}"}]},"source":{"line":50,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-get-3"},{"id":"tmux_window_link:link/3","publicId":"tmux_window_link:link/3","qualifiedName":"tmux_window_link:link/3","name":"link/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"link(Link, Session, Options)\n-spec link(tmux_model:window_link(),\n           tmux_model:session(),\n           placement_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":40,"end":62,"target":"t:tmux_model:window_link/0"},{"start":77,"end":95,"target":"t:tmux_model:session/0"},{"start":110,"end":127,"target":"t:tmux_window_link:placement_options/0"},{"start":153,"end":177,"target":"t:tmux_operation:completed/0"},{"start":205,"end":227,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"placement_options()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_window_link:placement_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Add another membership of this link's physical window to the destination session and explicit index. Defaults to detached and refuses an occupied index. replace = true maps to tmux -k and can destroy the occupied window. Returns the command result; use `get/3` to observe the new membership. The source membership remains. Session groups and renumber-windows retain their tmux semantics. Performs I/O after owner and membership checks."},"source":{"line":87,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-link-3"},{"id":"tmux_window_link:move/3","publicId":"tmux_window_link:move/3","qualifiedName":"tmux_window_link:move/3","name":"move/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"move(Link, Session, Options)\n-spec move(tmux_model:window_link(),\n           tmux_model:session(),\n           placement_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":40,"end":62,"target":"t:tmux_model:window_link/0"},{"start":77,"end":95,"target":"t:tmux_model:session/0"},{"start":110,"end":127,"target":"t:tmux_window_link:placement_options/0"},{"start":153,"end":177,"target":"t:tmux_operation:completed/0"},{"start":205,"end":227,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Session","type":"tmux_model:session()","typeReferences":[{"start":0,"end":18,"target":"t:tmux_model:session/0"}]},{"name":"Options","type":"placement_options()","typeReferences":[{"start":0,"end":17,"target":"t:tmux_window_link:placement_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Move this membership to the destination session and explicit index, leaving its physical window's other links intact. Placement options follow `link/3`. Moving the final window out of a session can destroy that session; automatic renumbering and session groups can change other memberships. Captured rows remain unchanged. Returns the command result after observed preflight."},"source":{"line":98,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-move-3"},{"id":"tmux_window_link:select/1","publicId":"tmux_window_link:select/1","qualifiedName":"tmux_window_link:select/1","name":"select/1","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"select(Link)\n-spec select(tmux_model:window_link()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":26,"end":48,"target":"t:tmux_model:window_link/0"},{"start":76,"end":100,"target":"t:tmux_operation:completed/0"},{"start":130,"end":152,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Select this membership as its session's current window after checking the expected physical window. Performs I/O and returns the command result."},"source":{"line":70,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-select-1"},{"id":"tmux_window_link:swap/3","publicId":"tmux_window_link:swap/3","qualifiedName":"tmux_window_link:swap/3","name":"swap/3","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"swap(Source, Destination, Options)\n-spec swap(tmux_model:window_link(),\n           tmux_model:window_link(),\n           swap_options()) ->\n              {ok, tmux_operation:completed()} |\n              {error, tmux_operation:failure()}.","references":[{"start":46,"end":68,"target":"t:tmux_model:window_link/0"},{"start":83,"end":105,"target":"t:tmux_model:window_link/0"},{"start":120,"end":132,"target":"t:tmux_window_link:swap_options/0"},{"start":158,"end":182,"target":"t:tmux_operation:completed/0"},{"start":210,"end":232,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Source","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Destination","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Options","type":"swap_options()","typeReferences":[{"start":0,"end":12,"target":"t:tmux_window_link:swap_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Swap the physical windows at two checked memberships. Other links to either window remain intact. detach maps to tmux -d and defaults true. tmux applies its session-selection and group-synchronization rules. Returns the command result; old rows still name their original expected windows and can become stale. Performs I/O, with the documented gap between preflight and action."},"source":{"line":109,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-swap-3"},{"id":"tmux_window_link:unlink/2","publicId":"tmux_window_link:unlink/2","qualifiedName":"tmux_window_link:unlink/2","name":"unlink/2","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"function","modifiers":[],"signatures":[{"raw":"unlink(Link, Options)\n-spec unlink(tmux_model:window_link(), unlink_options()) ->\n                {ok, tmux_operation:completed()} |\n                {error, tmux_operation:failure()}.","references":[{"start":35,"end":57,"target":"t:tmux_model:window_link/0"},{"start":61,"end":75,"target":"t:tmux_window_link:unlink_options/0"},{"start":103,"end":127,"target":"t:tmux_operation:completed/0"},{"start":157,"end":179,"target":"t:tmux_operation:failure/0"}],"params":[{"name":"Link","type":"tmux_model:window_link()","typeReferences":[{"start":0,"end":22,"target":"t:tmux_model:window_link/0"}]},{"name":"Options","type":"unlink_options()","typeReferences":[{"start":0,"end":14,"target":"t:tmux_window_link:unlink_options/0"}]}],"returns":"{ok, tmux_operation:completed()} |\n          {error, tmux_operation:failure()}","returnsReferences":[{"start":5,"end":29,"target":"t:tmux_operation:completed/0"},{"start":53,"end":75,"target":"t:tmux_operation:failure/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Remove one checked membership. force defaults false, retaining tmux's protection for windows linked to only one session. force = true permits removing the last link, destroying that physical window and possibly its session. Duplicate links within one session retain tmux's native protection rules. Performs I/O and returns the command result without refreshing rows."},"source":{"line":128,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"tmux_window_link-unlink-2"},{"id":"t:tmux_window_link:index/0","publicId":"t:tmux_window_link:index/0","qualifiedName":"tmux_window_link:index/0","name":"index/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type index() :: 0..2147483647.","params":[],"references":[]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"An explicit tmux window index; relative and next-free selectors are not accepted."},"source":{"line":27,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window_link-index-0"},{"id":"t:tmux_window_link:placement_options/0","publicId":"t:tmux_window_link:placement_options/0","qualifiedName":"tmux_window_link:placement_options/0","name":"placement_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type placement_options() ::\n          #{index := index(),\n            detach => boolean(),\n            replace => boolean()}.","params":[],"references":[{"start":50,"end":55,"target":"t:tmux_window_link:index/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":81,"end":88,"target":"t:erlang:boolean/0"},{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":115,"end":122,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Destination index is required. Defaults: detach true, replace false. Replacement may destroy the destination window."},"source":{"line":29,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window_link-placement_options-0"},{"id":"t:tmux_window_link:swap_options/0","publicId":"t:tmux_window_link:swap_options/0","qualifiedName":"tmux_window_link:swap_options/0","name":"swap_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type swap_options() :: #{detach => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":36,"end":43,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Maps detach to tmux's -d flag, default true."},"source":{"line":31,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window_link-swap_options-0"},{"id":"t:tmux_window_link:unlink_options/0","publicId":"t:tmux_window_link:unlink_options/0","qualifiedName":"tmux_window_link:unlink_options/0","name":"unlink_options/0","namespace":"tmux_window_link","parent":"tmux_window_link","kind":"typealias","modifiers":[],"signatures":[{"raw":"-type unlink_options() :: #{force => boolean()}.","params":[],"references":[{"external":{"href":"https://www.erlang.org/doc/apps/erts/erlang.html#t:boolean/0","project":"Erlang/OTP"},"start":37,"end":44,"target":"t:erlang:boolean/0"}]}],"package":"libtmux_erlang","product":"core","apiScope":"exported","doc":{"summary":"Force defaults false. Force permits unlinking the last membership and destroying its physical window."},"source":{"line":33,"file":"apps/libtmux_erlang/src/tmux_window_link.erl","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","extractedRevision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64"},"slug":"t-tmux_window_link-unlink_options-0"}]}
diff --git a/site/src/data/api/erlang.paths.json b/site/src/data/api/erlang.paths.json
index c33a94f10..3a0fe6506 100644
--- a/site/src/data/api/erlang.paths.json
+++ b/site/src/data/api/erlang.paths.json
@@ -1 +1 @@
-{"port":"erlang","repo":"libtmux/libtmux-erlang","revision":"e858027b2b204c3e621b1f74e9419c9b71e3f2f5","paths":[".github/CONTRIBUTING.md",".github/WRITING.md",".github/dependabot.yml",".github/example-width.toml",".github/repository.json",".github/social-preview.png",".github/workflows/ci.yml",".github/workflows/docs.yml",".gitignore",".tool-versions","AGENTS.md","CHANGELOG.md","CLAUDE.md","LICENSE","README.md","apps/libtmux_erlang/CHANGELOG.md","apps/libtmux_erlang/LICENSE","apps/libtmux_erlang/README.md","apps/libtmux_erlang/assets/logo-128.png","apps/libtmux_erlang/assets/logo.svg","apps/libtmux_erlang/assets/source.json","apps/libtmux_erlang/c_src/LICENSE","apps/libtmux_erlang/c_src/Makefile","apps/libtmux_erlang/c_src/README.md","apps/libtmux_erlang/c_src/owned_io.c","apps/libtmux_erlang/c_src/provenance.json","apps/libtmux_erlang/rebar.config","apps/libtmux_erlang/src/libtmux_erlang.app.src","apps/libtmux_erlang/src/libtmux_erlang_app.erl","apps/libtmux_erlang/src/tmux_admission.erl","apps/libtmux_erlang/src/tmux_args.erl","apps/libtmux_erlang/src/tmux_buffer.erl","apps/libtmux_erlang/src/tmux_buffer_codec.erl","apps/libtmux_erlang/src/tmux_capability.erl","apps/libtmux_erlang/src/tmux_capability_data.erl","apps/libtmux_erlang/src/tmux_command.erl","apps/libtmux_erlang/src/tmux_control.erl","apps/libtmux_erlang/src/tmux_control_codec.erl","apps/libtmux_erlang/src/tmux_error.erl","apps/libtmux_erlang/src/tmux_filter.erl","apps/libtmux_erlang/src/tmux_filter_eval.erl","apps/libtmux_erlang/src/tmux_hook.erl","apps/libtmux_erlang/src/tmux_identity.erl","apps/libtmux_erlang/src/tmux_json.erl","apps/libtmux_erlang/src/tmux_key.erl","apps/libtmux_erlang/src/tmux_log.erl","apps/libtmux_erlang/src/tmux_matcher.erl","apps/libtmux_erlang/src/tmux_model.erl","apps/libtmux_erlang/src/tmux_observe.erl","apps/libtmux_erlang/src/tmux_operation.erl","apps/libtmux_erlang/src/tmux_option.erl","apps/libtmux_erlang/src/tmux_option_batch.erl","apps/libtmux_erlang/src/tmux_option_codec.erl","apps/libtmux_erlang/src/tmux_option_data.erl","apps/libtmux_erlang/src/tmux_option_scope.erl","apps/libtmux_erlang/src/tmux_owned_server.erl","apps/libtmux_erlang/src/tmux_pane.erl","apps/libtmux_erlang/src/tmux_query.erl","apps/libtmux_erlang/src/tmux_query_plan.erl","apps/libtmux_erlang/src/tmux_regex.erl","apps/libtmux_erlang/src/tmux_registry.erl","apps/libtmux_erlang/src/tmux_schema.erl","apps/libtmux_erlang/src/tmux_schema_data.erl","apps/libtmux_erlang/src/tmux_scope.erl","apps/libtmux_erlang/src/tmux_select.erl","apps/libtmux_erlang/src/tmux_server.erl","apps/libtmux_erlang/src/tmux_session.erl","apps/libtmux_erlang/src/tmux_snapshot.erl","apps/libtmux_erlang/src/tmux_sup.erl","apps/libtmux_erlang/src/tmux_target.erl","apps/libtmux_erlang/src/tmux_text_codec.erl","apps/libtmux_erlang/src/tmux_transport.erl","apps/libtmux_erlang/src/tmux_transport_codec.erl","apps/libtmux_erlang/src/tmux_version.erl","apps/libtmux_erlang/src/tmux_window.erl","apps/libtmux_erlang/src/tmux_window_link.erl","apps/libtmux_erlang/test/tmux_admission_tests.erl","apps/libtmux_erlang/test/tmux_buffer_tests.erl","apps/libtmux_erlang/test/tmux_capability_tests.erl","apps/libtmux_erlang/test/tmux_command_tests.erl","apps/libtmux_erlang/test/tmux_domain_tests.erl","apps/libtmux_erlang/test/tmux_error_tests.erl","apps/libtmux_erlang/test/tmux_filter_fixture_tests.erl","apps/libtmux_erlang/test/tmux_filter_tests.erl","apps/libtmux_erlang/test/tmux_hook_tests.erl","apps/libtmux_erlang/test/tmux_identity_tests.erl","apps/libtmux_erlang/test/tmux_json_tests.erl","apps/libtmux_erlang/test/tmux_key_tests.erl","apps/libtmux_erlang/test/tmux_model_tests.erl","apps/libtmux_erlang/test/tmux_option_tests.erl","apps/libtmux_erlang/test/tmux_query_tests.erl","apps/libtmux_erlang/test/tmux_regex_tests.erl","apps/libtmux_erlang/test/tmux_registry_tests.erl","apps/libtmux_erlang/test/tmux_scope_tests.erl","apps/libtmux_erlang/test/tmux_select_tests.erl","apps/libtmux_erlang/test/tmux_snapshot_tests.erl","apps/libtmux_erlang/test/tmux_text_codec_tests.erl","apps/libtmux_erlang/test/tmux_transport_codec_tests.erl","apps/libtmux_erlang/test/tmux_version_tests.erl","docs/adr-0001-architecture.md","docs/adr-0002-batched-hydration.md","docs/adr-0003-scoped-option-batches.md","docs/api.md","docs/assets/app-icon-1024-dark.png","docs/assets/app-icon-1024-light.png","docs/assets/apple-touch-icon-dark.png","docs/assets/apple-touch-icon-light.png","docs/assets/browserconfig-dark.xml","docs/assets/browserconfig.xml","docs/assets/favicon.ico","docs/assets/logo-1024.png","docs/assets/logo-128.png","docs/assets/logo-144.png","docs/assets/logo-152.png","docs/assets/logo-16.png","docs/assets/logo-167.png","docs/assets/logo-180.png","docs/assets/logo-192.png","docs/assets/logo-24.png","docs/assets/logo-256.png","docs/assets/logo-32.png","docs/assets/logo-384.png","docs/assets/logo-48.png","docs/assets/logo-512.png","docs/assets/logo-64.png","docs/assets/logo-96.png","docs/assets/logo.svg","docs/assets/maskable-192-dark.png","docs/assets/maskable-192-light.png","docs/assets/maskable-512-dark.png","docs/assets/maskable-512-light.png","docs/assets/mstile-150-dark.png","docs/assets/mstile-150-light.png","docs/assets/mstile-310-dark.png","docs/assets/mstile-310-light.png","docs/assets/opengraph-dark.jpg","docs/assets/opengraph-dark.png","docs/assets/opengraph-light.jpg","docs/assets/opengraph-light.png","docs/assets/safari-pinned-tab.svg","docs/assets/site-dark.webmanifest","docs/assets/site.webmanifest","docs/assets/social-square-dark.png","docs/assets/social-square-light.png","docs/assets/source.json","docs/assets/twitter-dark.png","docs/assets/twitter-light.png","docs/branding.md","docs/buffers.md","docs/commands-reference.md","docs/commands.md","docs/compatibility.md","docs/configuration.md","docs/control.md","docs/diagnostics.md","docs/fields.md","docs/graph.md","docs/guides.md","docs/hooks.md","docs/installation.md","docs/jobs.md","docs/keys.md","docs/options-reference.md","docs/options.md","docs/ownership.md","docs/panes.md","docs/pipe.md","docs/project-policy.md","docs/querying.md","examples/buffer_demo.erl","examples/command_demo.erl","examples/config_demo.erl","examples/control_demo.erl","examples/filter_demo.erl","examples/hook_demo.erl","examples/inspect_demo.erl","examples/job_demo.erl","examples/key_demo.erl","examples/linked_graph.erl","examples/native_consumer.erl","examples/options_demo.erl","examples/pane_demo.erl","examples/pipe_demo.erl","examples/readme_demo.erl","examples/terminal_job.py","llms.txt","property/prop_tmux_filter.erl","property/prop_tmux_graph.erl","rebar.config","rebar.lock","schema/commands.json","schema/entities.json","schema/options.json","test/ci_cache_tests.py","test/command_catalogue_tests.py","test/consumers/model_types_bad.erl","test/consumers/model_types_ok.erl","test/example_protocol_tests.py","test/fixtures/README.md","test/fixtures/filters-v1.json","test/fixtures/regex-v1.json","test/helper_fuzz.c","test/helper_protocol.py","test/tmux_buffer_SUITE.erl","test/tmux_channel_SUITE.erl","test/tmux_command_SUITE.erl","test/tmux_control_SUITE.erl","test/tmux_control_codec_SUITE.erl","test/tmux_control_codec_tests.erl","test/tmux_diagnostics_SUITE.erl","test/tmux_docs_SUITE.erl","test/tmux_domain_SUITE.erl","test/tmux_fixture_SUITE.erl","test/tmux_fixture_watch.py","test/tmux_hook_SUITE.erl","test/tmux_key_SUITE.erl","test/tmux_key_SUITE_data/client.py","test/tmux_option_SUITE.erl","test/tmux_owned_server_SUITE.erl","test/tmux_pipe_SUITE.erl","test/tmux_query_SUITE.erl","test/tmux_server_SUITE.erl","test/tmux_test_fixture.erl","test/tmux_topology_SUITE.erl","test/tmux_transport_SUITE.erl","tools/build_docs.py","tools/check.py","tools/check_api_docs.escript","tools/check_docs.py","tools/check_example_width.py","tools/check_helper_native.py","tools/check_model_types.escript","tools/check_package.py","tools/check_regex.py","tools/check_source_package.py","tools/ci/README.md","tools/ci/build_tmux.py","tools/ci/tmux-sources.json","tools/docs-tool.json","tools/filter-conformance/README.md","tools/filter-conformance/check.py","tools/filter-conformance/consumer.exs","tools/generate_commands.py","tools/generate_options.py","tools/generate_reference.escript","tools/generate_schema.escript","tools/package-tool.json","tools/regex-conformance/Cargo.lock","tools/regex-conformance/Cargo.toml","tools/regex-conformance/README.md","tools/regex-conformance/generate_fixture.py","tools/regex-conformance/javascript.mjs","tools/regex-conformance/src/main.rs","tools/regex_fixture.escript","tools/run_examples.escript","tools/source_package_registry.escript"]}
+{"port":"erlang","repo":"libtmux/libtmux-erlang","revision":"539c7297ceae65a1cf683e0836eae0a1ccd34d64","paths":[".github/CONTRIBUTING.md",".github/RELEASE.md",".github/WRITING.md",".github/dependabot.yml",".github/example-width.toml",".github/repository.json",".github/social-preview.png",".github/workflows/ci.yml",".github/workflows/docs.yml",".github/workflows/release.yml",".gitignore",".tool-versions","AGENTS.md","CHANGELOG.md","CLAUDE.md","LICENSE","README.md","apps/libtmux_erlang/CHANGELOG.md","apps/libtmux_erlang/LICENSE","apps/libtmux_erlang/README.md","apps/libtmux_erlang/assets/logo-128.png","apps/libtmux_erlang/assets/logo-512.png","apps/libtmux_erlang/assets/logo.svg","apps/libtmux_erlang/assets/source.json","apps/libtmux_erlang/c_src/LICENSE","apps/libtmux_erlang/c_src/Makefile","apps/libtmux_erlang/c_src/README.md","apps/libtmux_erlang/c_src/owned_io.c","apps/libtmux_erlang/c_src/provenance.json","apps/libtmux_erlang/rebar.config","apps/libtmux_erlang/src/libtmux_erlang.app.src","apps/libtmux_erlang/src/libtmux_erlang_app.erl","apps/libtmux_erlang/src/tmux_admission.erl","apps/libtmux_erlang/src/tmux_args.erl","apps/libtmux_erlang/src/tmux_buffer.erl","apps/libtmux_erlang/src/tmux_buffer_codec.erl","apps/libtmux_erlang/src/tmux_capability.erl","apps/libtmux_erlang/src/tmux_capability_data.erl","apps/libtmux_erlang/src/tmux_command.erl","apps/libtmux_erlang/src/tmux_control.erl","apps/libtmux_erlang/src/tmux_control_codec.erl","apps/libtmux_erlang/src/tmux_error.erl","apps/libtmux_erlang/src/tmux_filter.erl","apps/libtmux_erlang/src/tmux_filter_eval.erl","apps/libtmux_erlang/src/tmux_hook.erl","apps/libtmux_erlang/src/tmux_identity.erl","apps/libtmux_erlang/src/tmux_json.erl","apps/libtmux_erlang/src/tmux_key.erl","apps/libtmux_erlang/src/tmux_log.erl","apps/libtmux_erlang/src/tmux_matcher.erl","apps/libtmux_erlang/src/tmux_model.erl","apps/libtmux_erlang/src/tmux_observe.erl","apps/libtmux_erlang/src/tmux_operation.erl","apps/libtmux_erlang/src/tmux_option.erl","apps/libtmux_erlang/src/tmux_option_batch.erl","apps/libtmux_erlang/src/tmux_option_codec.erl","apps/libtmux_erlang/src/tmux_option_data.erl","apps/libtmux_erlang/src/tmux_option_scope.erl","apps/libtmux_erlang/src/tmux_owned_server.erl","apps/libtmux_erlang/src/tmux_pane.erl","apps/libtmux_erlang/src/tmux_query.erl","apps/libtmux_erlang/src/tmux_query_plan.erl","apps/libtmux_erlang/src/tmux_regex.erl","apps/libtmux_erlang/src/tmux_registry.erl","apps/libtmux_erlang/src/tmux_schema.erl","apps/libtmux_erlang/src/tmux_schema_data.erl","apps/libtmux_erlang/src/tmux_scope.erl","apps/libtmux_erlang/src/tmux_select.erl","apps/libtmux_erlang/src/tmux_server.erl","apps/libtmux_erlang/src/tmux_session.erl","apps/libtmux_erlang/src/tmux_snapshot.erl","apps/libtmux_erlang/src/tmux_sup.erl","apps/libtmux_erlang/src/tmux_target.erl","apps/libtmux_erlang/src/tmux_text_codec.erl","apps/libtmux_erlang/src/tmux_transport.erl","apps/libtmux_erlang/src/tmux_transport_codec.erl","apps/libtmux_erlang/src/tmux_version.erl","apps/libtmux_erlang/src/tmux_window.erl","apps/libtmux_erlang/src/tmux_window_link.erl","apps/libtmux_erlang/test/tmux_admission_tests.erl","apps/libtmux_erlang/test/tmux_buffer_tests.erl","apps/libtmux_erlang/test/tmux_capability_tests.erl","apps/libtmux_erlang/test/tmux_command_tests.erl","apps/libtmux_erlang/test/tmux_domain_tests.erl","apps/libtmux_erlang/test/tmux_error_tests.erl","apps/libtmux_erlang/test/tmux_filter_fixture_tests.erl","apps/libtmux_erlang/test/tmux_filter_tests.erl","apps/libtmux_erlang/test/tmux_hook_tests.erl","apps/libtmux_erlang/test/tmux_identity_tests.erl","apps/libtmux_erlang/test/tmux_json_tests.erl","apps/libtmux_erlang/test/tmux_key_tests.erl","apps/libtmux_erlang/test/tmux_model_tests.erl","apps/libtmux_erlang/test/tmux_option_tests.erl","apps/libtmux_erlang/test/tmux_query_tests.erl","apps/libtmux_erlang/test/tmux_regex_tests.erl","apps/libtmux_erlang/test/tmux_registry_tests.erl","apps/libtmux_erlang/test/tmux_scope_tests.erl","apps/libtmux_erlang/test/tmux_select_tests.erl","apps/libtmux_erlang/test/tmux_snapshot_tests.erl","apps/libtmux_erlang/test/tmux_text_codec_tests.erl","apps/libtmux_erlang/test/tmux_transport_codec_tests.erl","apps/libtmux_erlang/test/tmux_version_tests.erl","docs/adr-0001-architecture.md","docs/adr-0002-batched-hydration.md","docs/adr-0003-scoped-option-batches.md","docs/api.md","docs/assets/app-icon-1024-dark.png","docs/assets/app-icon-1024-light.png","docs/assets/apple-touch-icon-dark.png","docs/assets/apple-touch-icon-light.png","docs/assets/browserconfig-dark.xml","docs/assets/browserconfig.xml","docs/assets/favicon.ico","docs/assets/logo-1024.png","docs/assets/logo-128.png","docs/assets/logo-144.png","docs/assets/logo-152.png","docs/assets/logo-16.png","docs/assets/logo-167.png","docs/assets/logo-180.png","docs/assets/logo-192.png","docs/assets/logo-24.png","docs/assets/logo-256.png","docs/assets/logo-32.png","docs/assets/logo-384.png","docs/assets/logo-48.png","docs/assets/logo-512.png","docs/assets/logo-64.png","docs/assets/logo-96.png","docs/assets/logo.svg","docs/assets/maskable-192-dark.png","docs/assets/maskable-192-light.png","docs/assets/maskable-512-dark.png","docs/assets/maskable-512-light.png","docs/assets/mstile-150-dark.png","docs/assets/mstile-150-light.png","docs/assets/mstile-310-dark.png","docs/assets/mstile-310-light.png","docs/assets/opengraph-dark.jpg","docs/assets/opengraph-dark.png","docs/assets/opengraph-light.jpg","docs/assets/opengraph-light.png","docs/assets/safari-pinned-tab.svg","docs/assets/site-dark.webmanifest","docs/assets/site.webmanifest","docs/assets/social-square-dark.png","docs/assets/social-square-light.png","docs/assets/source.json","docs/assets/twitter-dark.png","docs/assets/twitter-light.png","docs/branding.md","docs/buffers.md","docs/commands-reference.md","docs/commands.md","docs/compatibility.md","docs/configuration.md","docs/control.md","docs/diagnostics.md","docs/fields.md","docs/graph.md","docs/guides.md","docs/hooks.md","docs/installation.md","docs/jobs.md","docs/keys.md","docs/options-reference.md","docs/options.md","docs/ownership.md","docs/panes.md","docs/pipe.md","docs/project-policy.md","docs/querying.md","examples/buffer_demo.erl","examples/command_demo.erl","examples/config_demo.erl","examples/control_demo.erl","examples/filter_demo.erl","examples/hook_demo.erl","examples/inspect_demo.erl","examples/job_demo.erl","examples/key_demo.erl","examples/linked_graph.erl","examples/native_consumer.erl","examples/options_demo.erl","examples/pane_demo.erl","examples/pipe_demo.erl","examples/readme_demo.erl","examples/terminal_job.py","llms.txt","property/prop_tmux_filter.erl","property/prop_tmux_graph.erl","rebar.config","rebar.lock","schema/commands.json","schema/entities.json","schema/options.json","test/ci_cache_tests.py","test/command_catalogue_tests.py","test/consumers/model_types_bad.erl","test/consumers/model_types_ok.erl","test/example_protocol_tests.py","test/fixtures/README.md","test/fixtures/filters-v1.json","test/fixtures/regex-v1.json","test/helper_fuzz.c","test/helper_protocol.py","test/release_tests.py","test/tmux_buffer_SUITE.erl","test/tmux_channel_SUITE.erl","test/tmux_command_SUITE.erl","test/tmux_control_SUITE.erl","test/tmux_control_codec_SUITE.erl","test/tmux_control_codec_tests.erl","test/tmux_diagnostics_SUITE.erl","test/tmux_docs_SUITE.erl","test/tmux_domain_SUITE.erl","test/tmux_fixture_SUITE.erl","test/tmux_fixture_watch.py","test/tmux_hook_SUITE.erl","test/tmux_key_SUITE.erl","test/tmux_key_SUITE_data/client.py","test/tmux_option_SUITE.erl","test/tmux_owned_server_SUITE.erl","test/tmux_pipe_SUITE.erl","test/tmux_query_SUITE.erl","test/tmux_server_SUITE.erl","test/tmux_test_fixture.erl","test/tmux_topology_SUITE.erl","test/tmux_transport_SUITE.erl","tools/build_docs.py","tools/check.py","tools/check_api_docs.escript","tools/check_docs.py","tools/check_example_width.py","tools/check_helper_native.py","tools/check_hex_install.py","tools/check_model_types.escript","tools/check_package.py","tools/check_regex.py","tools/check_release.py","tools/check_source_package.py","tools/ci/README.md","tools/ci/build_tmux.py","tools/ci/tmux-sources.json","tools/docs-tool.json","tools/filter-conformance/README.md","tools/filter-conformance/check.py","tools/filter-conformance/consumer.exs","tools/generate_commands.py","tools/generate_options.py","tools/generate_reference.escript","tools/generate_schema.escript","tools/package-tool.json","tools/regex-conformance/Cargo.lock","tools/regex-conformance/Cargo.toml","tools/regex-conformance/README.md","tools/regex-conformance/generate_fixture.py","tools/regex-conformance/javascript.mjs","tools/regex-conformance/src/main.rs","tools/regex_fixture.escript","tools/run_examples.escript","tools/source_package_registry.escript"]}
diff --git a/site/src/data/api/perl.json b/site/src/data/api/perl.json
index 21b2ee633..93cd88c62 100644
--- a/site/src/data/api/perl.json
+++ b/site/src/data/api/perl.json
@@ -1 +1 @@
-{"port":"perl","repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","sources":[{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","package":"LibTmux","product":"core","repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","version":"0.001_001"},{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","package":"LibTmux-Async","product":"core","repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","version":"0.001_001"},{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","package":"LibTmux-Workspace","product":"workspace","repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","version":"0.001_001"}],"extractor":"Perl PPI 1.291 + Pod::Simple native POD v1","nativeProvenance":{"exporter":{"file":"scripts/export-api.pl","perl":"v5.44.0","ppi":"1.291","repository":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","sha256":"445d306968a0656f1b8542665daee83674f7f89bf8f8256093e88a58505c9d3e","working_tree":false},"files":[{"path":"packages/core/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/core/Makefile.PL","sha256":"b1676ac18d88f57e08ed6ddf463af66c5752bd41ce0e8dd8074329a3e38f60af"},{"path":"packages/core/README.md","sha256":"caafec35911b637f811ca3a388a87f797fb9c554325dbb20251d2de48efcea85"},{"path":"packages/core/cpanfile","sha256":"c3872a5a5b6b7f367534376cd4db51f7ebf4a1ee31a4560c0de2661c9b25bdf7"},{"path":"packages/core/lib/LibTmux.pm","sha256":"f4716e9b7ba03c66fa57c084ac0803c68968ccacb37ff54a15023e34e854080c"},{"path":"packages/core/lib/LibTmux/Client.pm","sha256":"1d6a7fe38802d134215f476727e014cceb7f189d608a45e907aa74a9b33377a3"},{"path":"packages/core/lib/LibTmux/ClientSelection.pm","sha256":"24c200afefcb28a5df984b99db8df4253986176b005daf175ecd3f45ebc50aab"},{"path":"packages/core/lib/LibTmux/Codec.pm","sha256":"c3517cd3542e7622b575ddf3a8274841e43df843d4b9b4739d79268ed047a327"},{"path":"packages/core/lib/LibTmux/CommandResult.pm","sha256":"c05fee72a809d924d96908eeb5c9d4c328b088d5e4f9692f292f9c96b13fdbd9"},{"path":"packages/core/lib/LibTmux/Entity.pm","sha256":"46fbe507850d5880f59d78a732270e2554d5e4fe112d8a8013e60a9fca0d5c20"},{"path":"packages/core/lib/LibTmux/Filter.pm","sha256":"fa3b65a22515a6086d06f044e06eeb454575b926e41216419f445d084c8cd8bc"},{"path":"packages/core/lib/LibTmux/Operation.pm","sha256":"dc63406ae06d858fad89347a146cb7ba8496e6db9ee5eaf1ab278e2a67d250e3"},{"path":"packages/core/lib/LibTmux/Pane.pm","sha256":"1d34d763df3256c8645b91395788d0e863e1bff80115a473494b23c4525f3040"},{"path":"packages/core/lib/LibTmux/PaneSelection.pm","sha256":"6edb85943a642e56afcc5185b905c4fc82fcb9c3ca35d013aa61627421354fc5"},{"path":"packages/core/lib/LibTmux/Platform/Linux.pm","sha256":"15d720b545a11c3835e94b672bab6719fbc7dc6b9645ad5edb90207cb12a8968"},{"path":"packages/core/lib/LibTmux/ProcessJob.pm","sha256":"fd46908c18f4b034cd74b1c8e10b1525d7270e60159e32e6c45b0778425be642"},{"path":"packages/core/lib/LibTmux/QueryPlan.pm","sha256":"3f18a903100e46dcb58c32b7ad6a4853df8094f8932a56644b33d6e4dd5668fa"},{"path":"packages/core/lib/LibTmux/Schema.pm","sha256":"69290dbf72abe7cb27d9364b519f261281088d59abd4c17af33026adf4d7a52f"},{"path":"packages/core/lib/LibTmux/Selection.pm","sha256":"12565d289dcb00e13852d297cbd843a65a9bab43c0e6cab6392bc6fdf8749c99"},{"path":"packages/core/lib/LibTmux/Selection/Iterator.pm","sha256":"755aaf2aa31e3302422d00573bd4ce4d26be8017f1d008b12be1f64708496d40"},{"path":"packages/core/lib/LibTmux/Server.pm","sha256":"2ee3f86b2a377d31692321c19928845f49463a6faa1e231bf4fadb5825be23ef"},{"path":"packages/core/lib/LibTmux/Session.pm","sha256":"937f4399513d814108380b75beb1c8824960593354f3955559439e2bc999da83"},{"path":"packages/core/lib/LibTmux/SessionSelection.pm","sha256":"8ba23cdcf527ceb555ce392857c2b43b86b1b55ab4e881e5dc733ced99e95f4c"},{"path":"packages/core/lib/LibTmux/Snapshot.pm","sha256":"d25f65b94405c1d9cb3ff3f0e268de567d79d4aca178efa66c14db8bd040df5d"},{"path":"packages/core/lib/LibTmux/Transport.pm","sha256":"57dcb66db1c204f7fe6bcfee6623742dcfe425d8f9f0220e126d8e7c0a6535dc"},{"path":"packages/core/lib/LibTmux/Window.pm","sha256":"df01e902cc513dee0e7458c2499078ca9141446066a822525a2e45864942e06e"},{"path":"packages/core/lib/LibTmux/WindowLink.pm","sha256":"30c8937a5806bb2996af3b21c3a6936a383a3e34ead6d591748a077b7b6adebf"},{"path":"packages/core/lib/LibTmux/WindowLinkSelection.pm","sha256":"8301d518b97d620f76c7d1c7927c14809962a48b9ae5027768ea2163395550f1"},{"path":"packages/core/lib/LibTmux/WindowSelection.pm","sha256":"8b7956f6360344d3c3f8c7b1759f2e53e0acbbc98e81d2f3f864c339b8fcf8c2"},{"path":"packages/core/lib/LibTmux/X.pm","sha256":"83438781e81322c06006dd84fe7bf357472a34c1e3e3a502babdc5b040036195"},{"path":"packages/core/lib/LibTmux/schema.json","sha256":"5f132d204d5c919cdab5083233da5a1c0aedf4690f72fe430c1c8b1b271cb1e9"},{"path":"packages/async/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/async/Makefile.PL","sha256":"d286c34dea28a19e5dee6676994572948484a14dcced38ac3c2b5ad836874d74"},{"path":"packages/async/README.md","sha256":"c966ad175401c58b69bcc76c74f7245b88299bf0c49f84ea72da107614ec41ad"},{"path":"packages/async/cpanfile","sha256":"c41a2e0987205267d3b501621a8868e3939a23f4af9cf3ee7be311d4d915cc75"},{"path":"packages/async/lib/LibTmux/Async.pm","sha256":"1f408d07f32ce01839b25a6e3974c89153cd470834587f4bffbad6b4c272b522"},{"path":"packages/async/lib/LibTmux/Async/Server.pm","sha256":"65af3416d55200c0d10d4a2a8982280254ee28b5d06b15222a1da7da6beeea11"},{"path":"packages/async/lib/LibTmux/Async/Transport.pm","sha256":"67c30dd33016be2f7161aeaa4aab0ff3a153b06c8739a32fc9a8786642dc9375"},{"path":"packages/async/lib/LibTmux/Async/X.pm","sha256":"c1f342b52f45de5eee2c1970e806049a373f0f88d1c579ae4c157ed40756d272"},{"path":"packages/workspace/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/workspace/Makefile.PL","sha256":"e0cd4934a909b4af792040dbaa9f29f430b0873cf1dd4be5d1079df03b177515"},{"path":"packages/workspace/README.md","sha256":"003c89eebfae69f34542579cc5997cb223e91feeaaa091f96c5b7fcea248c2fd"},{"path":"packages/workspace/cpanfile","sha256":"1acf55e302b84a6050525354e8887ca39ae45c8b0e908ff9fc3ffa23cb7ad246"},{"path":"packages/workspace/lib/LibTmux/Workspace.pm","sha256":"4433b6524afcdbb09150231eaf42918030bb2fbeb469e8cafe9187cdbf4e063d"},{"path":"packages/workspace/lib/LibTmux/Workspace/X.pm","sha256":"10c8aeefee1eff75d303559f1a30d4a71705ba638fa95e630fad0b4df04c0220"},{"path":"examples/quickstart.pl","sha256":"ba9f650b81972f6b11556c4babd22b19d868335d9701980069e5d37748ce3cf2"},{"path":"examples/selection.pl","sha256":"2f558f90969300ba7d2b86dac55a07a23b140ea60c921a282ddf231e9dd98093"},{"path":"examples/workspace.pl","sha256":"6f0b49432880a956960fcc19c02fe1ed0c7eeb4f57f2131e17162c4ecb65fbf3"},{"path":"examples/async.pl","sha256":"f194d964b977c4249b06e6927cd2533a7725675cf4534377baa2d3e5ef1d9d9b"},{"path":"examples/await.pl","sha256":"4ba75608ce524ae2b0212c029bbdcb9d4d96c8aebfac5d96a227c48a28ef2294"}]},"symbols":[{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nUse :obj:`LibTmux::Server <LibTmux::Server>` for acquisition and commands. Captured entities and :obj:`LibTmux::Selection <LibTmux::Selection>` queries perform no tmux I/O.\n\n","summary":"Explicit tmux commands and captured graph queries"},"id":"LibTmux","kind":"module","modifiers":[],"name":"LibTmux","package":"LibTmux","product":"core","publicId":"LibTmux","qualifiedName":"LibTmux","signatures":[{"params":[],"raw":"package LibTmux;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nThe async distribution depends on :obj:`LibTmux <LibTmux>`, [IO::Async](https://metacpan.org/pod/IO::Async), [Future](https://metacpan.org/pod/Future), [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll), and [IO::Ppoll](https://metacpan.org/pod/IO::Ppoll). Use :obj:`LibTmux::Async::Server <LibTmux::Async::Server>` or :obj:`LibTmux::Async::Transport <LibTmux::Async::Transport>` with an explicitly supplied Ppoll loop. Core snapshot filtering remains local and synchronous. Async dependencies are not required by the core or workspace distributions.\n\n","summary":"Optional Future-based libtmux execution"},"id":"LibTmux::Async","kind":"module","modifiers":[],"name":"Async","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async","qualifiedName":"LibTmux::Async","signatures":[{"params":[],"raw":"package LibTmux::Async;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use IO::Async::Loop::Ppoll;\n    use LibTmux::Async::Server;\n    my $loop = IO::Async::Loop::Ppoll->new;\n    my $server = LibTmux::Async::Server->new(loop => $loop, socket_name => 'owned');\n    my $capture = $server->snapshot;\n    $loop->await($capture);\n    my $panes = $capture->get->panes->where({ active => true });\n    $loop->await($server->close);\n```\n\n","summary":"Optional Future facade over the core protocol","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse IO::Async::Loop::Ppoll;\nuse Future::AsyncAwait;\nuse LibTmux::Async::Server;\nuse LibTmuxFixture;\nasync sub capture_count ($server) {\n    my $snapshot = await $server->snapshot;\n    my $count    = $snapshot->panes->count;\n    await $server->close;\n    return $count;\n}\nLibTmuxFixture->run(\n    sub ($sync, $root) {\n        $sync->new_session(\n            name    => 'await-example',\n            command => ['/bin/sleep', '120']\n        );\n        my $loop   = IO::Async::Loop::Ppoll->new;\n        my $server = LibTmux::Async::Server->new(\n            loop        => $loop,\n            socket_path => \"$root/s\",\n            executable  => $ENV{LIBTMUX_TEST_TMUX} // 'tmux'\n        );\n        my $work = capture_count($server);\n        $loop->await($work);\n        die 'await result differs' unless $work->get == 1;\n        say 'optional caller await syntax: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/d9fa7c5278d243c671a29cdb00e3a911ac651bfa/examples/await.pl"}]},"id":"LibTmux::Async::Server","kind":"class","modifiers":[],"name":"Server","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::Server","qualifiedName":"LibTmux::Async::Server","signatures":[{"params":[],"raw":"package LibTmux::Async::Server;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"attach_argv\" in LibTmux::Server <LibTmux::Server::attach_argv>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::attach_argv","kind":"method","modifiers":["async"],"name":"attach_argv","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::attach_argv","qualifiedName":"LibTmux::Async::Server::attach_argv","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub attach_argv($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":88,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-attach_argv"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"batch\" in LibTmux::Server <LibTmux::Server::batch>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::batch","kind":"method","modifiers":["async"],"name":"batch","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::batch","qualifiedName":"LibTmux::Async::Server::batch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"requests"}],"raw":"sub batch($self, $requests)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":62,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-batch"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"capture_pane\" in LibTmux::Server <LibTmux::Server::capture_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::capture_pane","kind":"method","modifiers":["async"],"name":"capture_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::capture_pane","qualifiedName":"LibTmux::Async::Server::capture_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub capture_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":82,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-capture_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"clients\" in LibTmux::Server <LibTmux::Server::clients>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::clients","kind":"method","modifiers":["async"],"name":"clients","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::clients","qualifiedName":"LibTmux::Async::Server::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub clients($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":87,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-clients"},{"apiScope":"exported","doc":{"summary":"Cancel active operations, suppress subsequent command continuations, reject new operations, and return a fresh cleanup observer [Future](https://metacpan.org/pod/Future). Only successful `is_done` completion proves owned processes and pipes finished. Cancellation of an observer does not cancel cleanup. The caller must drive its borrowed loop through shutdown. No tmux server is destroyed by closing this facade."},"id":"LibTmux::Async::Server::close","kind":"method","modifiers":["async"],"name":"close","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::close","qualifiedName":"LibTmux::Async::Server::close","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub close($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":55,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-close"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"cmd\" in LibTmux::Server <LibTmux::Server::cmd>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::cmd","kind":"method","modifiers":["async"],"name":"cmd","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::cmd","qualifiedName":"LibTmux::Async::Server::cmd","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":20,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"argv","variadic":"positional"}],"raw":"sub cmd($self, @argv)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":60,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-cmd"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"delete_buffer\" in LibTmux::Server <LibTmux::Server::delete_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::delete_buffer","kind":"method","modifiers":["async"],"name":"delete_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::delete_buffer","qualifiedName":"LibTmux::Async::Server::delete_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub delete_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":103,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-delete_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"detach_client\" in LibTmux::Server <LibTmux::Server::detach_client>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::detach_client","kind":"method","modifiers":["async"],"name":"detach_client","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::detach_client","qualifiedName":"LibTmux::Async::Server::detach_client","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub detach_client($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-detach_client"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"execute\" in LibTmux::Server <LibTmux::Server::execute>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::execute","kind":"method","modifiers":["async"],"name":"execute","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::execute","qualifiedName":"LibTmux::Async::Server::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub execute($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":63,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-execute"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"explain_panes\" in LibTmux::Server <LibTmux::Server::explain_panes>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::explain_panes","kind":"method","modifiers":["async"],"name":"explain_panes","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::explain_panes","qualifiedName":"LibTmux::Async::Server::explain_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub explain_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":69,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-explain_panes"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"get_environment\" in LibTmux::Server <LibTmux::Server::get_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::get_environment","kind":"method","modifiers":["async"],"name":"get_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::get_environment","qualifiedName":"LibTmux::Async::Server::get_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":96,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-get_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"get_option\" in LibTmux::Server <LibTmux::Server::get_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::get_option","kind":"method","modifiers":["async"],"name":"get_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::get_option","qualifiedName":"LibTmux::Async::Server::get_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":91,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-get_option"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_pane\" in LibTmux::Server <LibTmux::Server::kill_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_pane","kind":"method","modifiers":["async"],"name":"kill_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_pane","qualifiedName":"LibTmux::Async::Server::kill_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":83,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-kill_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_server\" in LibTmux::Server <LibTmux::Server::kill_server>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_server","kind":"method","modifiers":["async"],"name":"kill_server","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_server","qualifiedName":"LibTmux::Async::Server::kill_server","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_server($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":86,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-kill_server"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_session\" in LibTmux::Server <LibTmux::Server::kill_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_session","kind":"method","modifiers":["async"],"name":"kill_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_session","qualifiedName":"LibTmux::Async::Server::kill_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-kill_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_window\" in LibTmux::Server <LibTmux::Server::kill_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_window","kind":"method","modifiers":["async"],"name":"kill_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_window","qualifiedName":"LibTmux::Async::Server::kill_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":84,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-kill_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"link_window\" in LibTmux::Server <LibTmux::Server::link_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::link_window","kind":"method","modifiers":["async"],"name":"link_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::link_window","qualifiedName":"LibTmux::Async::Server::link_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub link_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":72,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-link_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"listings\" in LibTmux::Server <LibTmux::Server::listings>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::listings","kind":"method","modifiers":["async"],"name":"listings","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::listings","qualifiedName":"LibTmux::Async::Server::listings","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"kind"}],"raw":"sub listings($self, $kind)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":61,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-listings"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"move_window\" in LibTmux::Server <LibTmux::Server::move_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::move_window","kind":"method","modifiers":["async"],"name":"move_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::move_window","qualifiedName":"LibTmux::Async::Server::move_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub move_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":74,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-move_window"},{"apiScope":"exported","doc":{"summary":"`new(loop => $loop, %connection_options)` constructs without I/O. Borrow an [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll); connection options belong to :obj:`\"new\" in LibTmux::Server <LibTmux::Server::new>`. `max_concurrent` and `max_queue` configure the owned :obj:`LibTmux::Async::Transport <LibTmux::Async::Transport>`. Its :obj:`backend and signal contract <LibTmux::Async::Transport::new>` applies to this facade. No event loop is run implicitly."},"id":"LibTmux::Async::Server::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new","qualifiedName":"LibTmux::Async::Server::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-new"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"new_session\" in LibTmux::Server <LibTmux::Server::new_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::new_session","kind":"method","modifiers":["async"],"name":"new_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new_session","qualifiedName":"LibTmux::Async::Server::new_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":64,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-new_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"new_window\" in LibTmux::Server <LibTmux::Server::new_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::new_window","kind":"method","modifiers":["async"],"name":"new_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new_window","qualifiedName":"LibTmux::Async::Server::new_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":65,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-new_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` for arguments, returned value, and completion. Its observer runs inline in void context; a returned [Future](https://metacpan.org/pod/Future) is ignored. Cancellation before the decision suppresses it. If the observer cancels its query or calls :obj:`\"close\" <LibTmux::Async::Server::close>`, cancellation takes precedence over subsequent return or exception delivery. Continue driving the loop until close cleanup completes."},"id":"LibTmux::Async::Server::query_panes","kind":"method","modifiers":["async"],"name":"query_panes","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::query_panes","qualifiedName":"LibTmux::Async::Server::query_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub query_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":68,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-query_panes"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"rename_session\" in LibTmux::Server <LibTmux::Server::rename_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::rename_session","kind":"method","modifiers":["async"],"name":"rename_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::rename_session","qualifiedName":"LibTmux::Async::Server::rename_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":18,"kind":"name","start":4},{"end":31,"kind":"parameter","parameter":0,"start":26}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":70,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-rename_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"rename_window\" in LibTmux::Server <LibTmux::Server::rename_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::rename_window","kind":"method","modifiers":["async"],"name":"rename_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::rename_window","qualifiedName":"LibTmux::Async::Server::rename_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":71,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-rename_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"resize_pane\" in LibTmux::Server <LibTmux::Server::resize_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::resize_pane","kind":"method","modifiers":["async"],"name":"resize_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::resize_pane","qualifiedName":"LibTmux::Async::Server::resize_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub resize_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":78,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-resize_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_layout\" in LibTmux::Server <LibTmux::Server::select_layout>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_layout","kind":"method","modifiers":["async"],"name":"select_layout","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_layout","qualifiedName":"LibTmux::Async::Server::select_layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_layout($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-select_layout"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_pane\" in LibTmux::Server <LibTmux::Server::select_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_pane","kind":"method","modifiers":["async"],"name":"select_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_pane","qualifiedName":"LibTmux::Async::Server::select_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":76,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-select_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_window\" in LibTmux::Server <LibTmux::Server::select_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_window","kind":"method","modifiers":["async"],"name":"select_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_window","qualifiedName":"LibTmux::Async::Server::select_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":75,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-select_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"send_keys\" in LibTmux::Server <LibTmux::Server::send_keys>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::send_keys","kind":"method","modifiers":["async"],"name":"send_keys","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::send_keys","qualifiedName":"LibTmux::Async::Server::send_keys","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_keys($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":80,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-send_keys"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"send_text\" in LibTmux::Server <LibTmux::Server::send_text>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::send_text","kind":"method","modifiers":["async"],"name":"send_text","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::send_text","qualifiedName":"LibTmux::Async::Server::send_text","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_text($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":81,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-send_text"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_buffer\" in LibTmux::Server <LibTmux::Server::set_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_buffer","kind":"method","modifiers":["async"],"name":"set_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_buffer","qualifiedName":"LibTmux::Async::Server::set_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":101,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-set_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_environment\" in LibTmux::Server <LibTmux::Server::set_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_environment","kind":"method","modifiers":["async"],"name":"set_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_environment","qualifiedName":"LibTmux::Async::Server::set_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":95,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-set_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_hook\" in LibTmux::Server <LibTmux::Server::set_hook>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_hook","kind":"method","modifiers":["async"],"name":"set_hook","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_hook","qualifiedName":"LibTmux::Async::Server::set_hook","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_hook($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":93,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-set_hook"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_option\" in LibTmux::Server <LibTmux::Server::set_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_option","kind":"method","modifiers":["async"],"name":"set_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_option","qualifiedName":"LibTmux::Async::Server::set_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":90,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-set_option"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_title\" in LibTmux::Server <LibTmux::Server::set_title>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_title","kind":"method","modifiers":["async"],"name":"set_title","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_title","qualifiedName":"LibTmux::Async::Server::set_title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_title($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":79,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-set_title"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"show_buffer\" in LibTmux::Server <LibTmux::Server::show_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::show_buffer","kind":"method","modifiers":["async"],"name":"show_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::show_buffer","qualifiedName":"LibTmux::Async::Server::show_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":102,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-show_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"show_hooks\" in LibTmux::Server <LibTmux::Server::show_hooks>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::show_hooks","kind":"method","modifiers":["async"],"name":"show_hooks","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::show_hooks","qualifiedName":"LibTmux::Async::Server::show_hooks","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_hooks($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":94,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-show_hooks"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for arguments, returned value, and completion.","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse IO::Async::Loop::Ppoll;\nuse LibTmux::Async::Server;\nuse LibTmuxFixture;\nLibTmuxFixture->run(\n    sub ($sync, $root) {\n        $sync->new_session(\n            name    => 'async-example',\n            command => ['/bin/sleep', '120']\n        );\n        my $loop   = IO::Async::Loop::Ppoll->new;\n        my $server = LibTmux::Async::Server->new(\n            loop           => $loop,\n            socket_path    => \"$root/s\",\n            executable     => $ENV{LIBTMUX_TEST_TMUX} // 'tmux',\n            max_concurrent => 2\n        );\n        my $snapshot = $server->snapshot;\n        $loop->await($snapshot);\n        die 'async snapshot missing pane'\n            unless $snapshot->get->panes->count == 1;\n        my $closed = $server->close;\n        $loop->await($closed);\n        die 'cleanup failed' unless $closed->is_done;\n        say 'async capture and cleanup: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/d9fa7c5278d243c671a29cdb00e3a911ac651bfa/examples/async.pl"}]},"id":"LibTmux::Async::Server::snapshot","kind":"method","modifiers":["async"],"name":"snapshot","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::snapshot","qualifiedName":"LibTmux::Async::Server::snapshot","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub snapshot($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":67,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-snapshot"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"split_pane\" in LibTmux::Server <LibTmux::Server::split_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::split_pane","kind":"method","modifiers":["async"],"name":"split_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::split_pane","qualifiedName":"LibTmux::Async::Server::split_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub split_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-split_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unlink_window\" in LibTmux::Server <LibTmux::Server::unlink_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unlink_window","kind":"method","modifiers":["async"],"name":"unlink_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unlink_window","qualifiedName":"LibTmux::Async::Server::unlink_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unlink_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":73,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-unlink_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unset_environment\" in LibTmux::Server <LibTmux::Server::unset_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unset_environment","kind":"method","modifiers":["async"],"name":"unset_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unset_environment","qualifiedName":"LibTmux::Async::Server::unset_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":21,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":98,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-unset_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unset_option\" in LibTmux::Server <LibTmux::Server::unset_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unset_option","kind":"method","modifiers":["async"],"name":"unset_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unset_option","qualifiedName":"LibTmux::Async::Server::unset_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Server.pm","line":92,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-server-unset_option"},{"apiScope":"exported","doc":{"body":"","summary":"Bounded asynchronous process execution"},"id":"LibTmux::Async::Transport","kind":"class","modifiers":[],"name":"Transport","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::Transport","qualifiedName":"LibTmux::Async::Transport","signatures":[{"params":[],"raw":"package LibTmux::Async::Transport;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-transport"},{"apiScope":"exported","doc":{"summary":"Begin idempotent shutdown and return a fresh observer Future. New admissions fail with :obj:`Closed <LibTmux::Async::X::Closed>`; queued requests are cancelled without dispatch and running jobs are cancelled. Cancelling an observer never cancels private cleanup. Only successful `is_done` completion proves all owned jobs, pipes, and watchers have completed cleanup. The borrowed loop remains usable. Callers must keep driving it through shutdown."},"id":"LibTmux::Async::Transport::close","kind":"method","modifiers":[],"name":"close","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::close","qualifiedName":"LibTmux::Async::Transport::close","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub close($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":218,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-transport-close"},{"apiScope":"exported","doc":{"body":"The shared :obj:`LibTmux::ProcessJob <LibTmux::ProcessJob>` owns supervision. Cancelling the Future requests cleanup; it does not prove exit or reverse command effects.","summary":"Accepts the same literal process arguments as :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>`. Returns a [Future](https://metacpan.org/pod/Future) yielding one :obj:`command result <LibTmux::CommandResult>`. Typed core exceptions remain the failure value. Queue overflow fails with :obj:`QueueFull <LibTmux::Async::X::QueueFull>` before dispatch. The backend is checked again at admission and launch. Child preparation failures retain a typed diagnostic and `dispatched` false, with supervisor exit still required before cleanup completes."},"id":"LibTmux::Async::Transport::execute","kind":"method","modifiers":[],"name":"execute","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::execute","qualifiedName":"LibTmux::Async::Transport::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"request","variadic":"keyword"}],"raw":"sub execute($self, %request)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":60,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-transport-execute"},{"apiScope":"exported","doc":{"body":"Ppoll blocks watched signals outside its atomic wait. Its shared SIGCHLD watch can outlive this transport. `close` leaves the caller-selected loop and its signal policy intact. Do not change the backend or its wait mask while jobs or cleanup remain active. Async children unblock only SIGCHLD before process supervision; other mask bits remain unchanged in the child. This lets a new tmux daemon observe pane exits without changing synchronous core's mask policy.","summary":"`new(loop => $loop, max_concurrent => 4, max_queue => 64)` borrows an [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll) backed by [IO::Ppoll](https://metacpan.org/pod/IO::Ppoll). Construct that class explicitly; automatic loop selection can choose an unsupported backend. Other classes, a substituted poll implementation, or a wait mask blocking SIGCHLD throw :obj:`Unsupported <LibTmux::X::Unsupported>` before dispatch. The loop owns supervisor reaping; competing external all-child reapers are unsupported. The library never runs, stops, or replaces it."},"id":"LibTmux::Async::Transport::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::new","qualifiedName":"LibTmux::Async::Transport::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-transport-new"},{"apiScope":"exported","doc":{"body":"","summary":"Shutdown has started and new work is refused. Callers may still observe cleanup through \"close\" in LibTmux::Async::Transport."},"id":"LibTmux::Async::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X","qualifiedName":"LibTmux::Async::X","signatures":[{"params":[],"raw":"package LibTmux::Async::X;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-x"},{"apiScope":"exported","doc":{"summary":"Shutdown has started and new work is refused. Callers may still observe cleanup through :obj:`\"close\" in LibTmux::Async::Transport <LibTmux::Async::Transport::close>`."},"id":"LibTmux::Async::X::Closed","kind":"exception","modifiers":[],"name":"Closed","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X::Closed","qualifiedName":"LibTmux::Async::X::Closed","signatures":[{"params":[],"raw":"package LibTmux::Async::X::Closed;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-x-closed"},{"apiScope":"exported","doc":{"summary":"The configured running and pending limits are occupied. No command was submitted for this request. Returned through a failed [Future](https://metacpan.org/pod/Future)."},"id":"LibTmux::Async::X::QueueFull","kind":"exception","modifiers":[],"name":"QueueFull","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X::QueueFull","qualifiedName":"LibTmux::Async::X::QueueFull","signatures":[{"params":[],"raw":"package LibTmux::Async::X::QueueFull;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/async/lib/LibTmux/Async/X.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-async-x-queuefull"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured client entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Client","kind":"class","modifiers":[],"name":"Client","package":"LibTmux","product":"core","publicId":"LibTmux::Client","qualifiedName":"LibTmux::Client","signatures":[{"params":[],"raw":"package LibTmux::Client;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Client::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::generation","qualifiedName":"LibTmux::Client::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::height","qualifiedName":"LibTmux::Client::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Client::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::id","qualifiedName":"LibTmux::Client::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Client::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::identity","qualifiedName":"LibTmux::Client::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Client::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::kind","qualifiedName":"LibTmux::Client::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Client::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::name","qualifiedName":"LibTmux::Client::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-name"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::pid","qualifiedName":"LibTmux::Client::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-pid"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Client::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::server_id","qualifiedName":"LibTmux::Client::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-server_id"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Session <LibTmux::Session>` entity or undef. Local captured data; no I/O."},"id":"LibTmux::Client::session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::session","qualifiedName":"LibTmux::Client::session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub session($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-session"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Client::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::to_record","qualifiedName":"LibTmux::Client::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-to_record"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Client::tty","kind":"method","modifiers":[],"name":"tty","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::tty","qualifiedName":"LibTmux::Client::tty","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub tty($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-tty"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::width","qualifiedName":"LibTmux::Client::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Client.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-client-width"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Client <LibTmux::Client>` handles from one server generation. Empty instances still validate against the client schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured client entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::ClientSelection","kind":"class","modifiers":[],"name":"ClientSelection","package":"LibTmux","product":"core","publicId":"LibTmux::ClientSelection","qualifiedName":"LibTmux::ClientSelection","signatures":[{"params":[],"raw":"package LibTmux::ClientSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ClientSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::ClientSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::count","qualifiedName":"LibTmux::ClientSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::ClientSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::exists","qualifiedName":"LibTmux::ClientSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::ClientSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::first","qualifiedName":"LibTmux::ClientSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::ClientSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::grep","qualifiedName":"LibTmux::ClientSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::ClientSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::iterator","qualifiedName":"LibTmux::ClientSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::ClientSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::new","qualifiedName":"LibTmux::ClientSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::ClientSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::one","qualifiedName":"LibTmux::ClientSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::ClientSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::one_or_undef","qualifiedName":"LibTmux::ClientSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::ClientSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::to_array","qualifiedName":"LibTmux::ClientSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::ClientSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::where","qualifiedName":"LibTmux::ClientSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-clientselection-where"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders are local and do not mutate the result or perform I/O. A lifecycle exception may expose a bounded partial result; it does not imply rollback or command completion. See :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>` and :obj:`LibTmux::X <LibTmux::X>`.\n\n","summary":"Completed or partial subprocess outcome"},"id":"LibTmux::CommandResult","kind":"class","modifiers":[],"name":"CommandResult","package":"LibTmux","product":"core","publicId":"LibTmux::CommandResult","qualifiedName":"LibTmux::CommandResult","signatures":[{"params":[],"raw":"package LibTmux::CommandResult;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult"},{"apiScope":"exported","doc":{"summary":"Return an exit code or undef when no child status is known."},"id":"LibTmux::CommandResult::exit_code","kind":"method","modifiers":[],"name":"exit_code","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::exit_code","qualifiedName":"LibTmux::CommandResult::exit_code","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub exit_code($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-exit_code"},{"apiScope":"exported","doc":{"summary":"Return the POSIX wait status or undef when unavailable."},"id":"LibTmux::CommandResult::raw_status","kind":"method","modifiers":[],"name":"raw_status","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::raw_status","qualifiedName":"LibTmux::CommandResult::raw_status","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub raw_status($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-raw_status"},{"apiScope":"exported","doc":{"summary":"Return a terminating signal number, zero for ordinary exit, or undef for unknown status."},"id":"LibTmux::CommandResult::signal","kind":"method","modifiers":[],"name":"signal","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::signal","qualifiedName":"LibTmux::CommandResult::signal","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub signal($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-signal"},{"apiScope":"exported","doc":{"summary":"Return separately retained stderr octets, possibly empty."},"id":"LibTmux::CommandResult::stderr","kind":"method","modifiers":[],"name":"stderr","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::stderr","qualifiedName":"LibTmux::CommandResult::stderr","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub stderr($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":4,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-stderr"},{"apiScope":"exported","doc":{"summary":"Return retained stdout octets, possibly empty. No text decoding occurs."},"id":"LibTmux::CommandResult::stdout","kind":"method","modifiers":[],"name":"stdout","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::stdout","qualifiedName":"LibTmux::CommandResult::stdout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub stdout($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":3,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-stdout"},{"apiScope":"exported","doc":{"summary":"Return true only when known status proves ordinary exit zero. Unknown status is never success."},"id":"LibTmux::CommandResult::success","kind":"method","modifiers":[],"name":"success","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::success","qualifiedName":"LibTmux::CommandResult::success","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub success($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/CommandResult.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-commandresult-success"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nField readers and relationships resolve locally in the retained graph. :obj:`\"to_record\" <LibTmux::Entity::to_record>` returns detached scalar record data. Handles retain no transport.\n\n\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Read-only handle retaining a captured graph"},"id":"LibTmux::Entity","kind":"class","modifiers":[],"name":"Entity","package":"LibTmux","product":"core","publicId":"LibTmux::Entity","qualifiedName":"LibTmux::Entity","signatures":[{"params":[],"raw":"package LibTmux::Entity;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Entity::generation","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::generation","qualifiedName":"LibTmux::Entity::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity-generation"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Entity::identity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::identity","qualifiedName":"LibTmux::Entity::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Entity::kind","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::kind","qualifiedName":"LibTmux::Entity::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity-kind"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Entity::server_id","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::server_id","qualifiedName":"LibTmux::Entity::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Entity::to_record","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::to_record","qualifiedName":"LibTmux::Entity::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-entity-to_record"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use LibTmux::Filter;\n    my $filter = LibTmux::Filter->new(\n        entity => 'pane', where => {width => {-gte => 120}},\n    );\n    my $matches = $snapshot->panes->where($filter);\n```\n\n\n## CONTRACT\n\nCompilation validates the entire tree and copies operands. Hash keys evaluate lexically; logical arrays retain input order. Missing reads throw; known-null ordering is false. String operators are literal. Relations use some/every/none and is/is_not with explicit dash prefixes in Perl data.\n\n`matches` accepts entities, plain records, and registered adapters. `to_data`/`to_json` export copies in libtmux.where/v1; `from_data`/`from_json` validate input. Regex/coderefs/cycles and non-UTF-8 byte-path wire operands are refused. Perl regex remains available through Selection `grep`.\n\n\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Validated, reusable local criteria and explicit wire data"},"id":"LibTmux::Filter","kind":"class","modifiers":[],"name":"Filter","package":"LibTmux","product":"core","publicId":"LibTmux::Filter","qualifiedName":"LibTmux::Filter","signatures":[{"params":[],"raw":"package LibTmux::Filter;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter"},{"apiScope":"exported","doc":{"summary":"Return the declared entity-kind string. It remains known for an empty :obj:`LibTmux::Selection <LibTmux::Selection>`."},"id":"LibTmux::Filter::entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::entity","qualifiedName":"LibTmux::Filter::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-entity"},{"apiScope":"exported","doc":{"summary":"`from_data($envelope)` validates the version, entity, fields, operators, and operands, then returns a compiled filter. Reject executable values, unknown versions, cycles, and unsupported regex nodes."},"id":"LibTmux::Filter::from_data","kind":"method","modifiers":[],"name":"from_data","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::from_data","qualifiedName":"LibTmux::Filter::from_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"data"}],"raw":"sub from_data($class, $data)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":315,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-from_data"},{"apiScope":"exported","doc":{"summary":"`from_json($json_octets)` decodes bounded JSON using core booleans and calls :obj:`\"from_data\" <LibTmux::Filter::from_data>`. Invalid JSON throws :obj:`InvalidFilter <LibTmux::X::InvalidFilter>`."},"id":"LibTmux::Filter::from_json","kind":"method","modifiers":[],"name":"from_json","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::from_json","qualifiedName":"LibTmux::Filter::from_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"bytes"}],"raw":"sub from_json($class, $bytes)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":331,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-from_json"},{"apiScope":"exported","doc":{"summary":"`matches($entity_or_record)` returns a native Boolean. Accept captured entities, plain hash records, or registered adapters of the declared kind. Missing required reads throw :obj:`Unloaded <LibTmux::X::Unloaded>`; they never become null or false through negation. Evaluation performs no I/O."},"id":"LibTmux::Filter::matches","kind":"method","modifiers":[],"name":"matches","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::matches","qualifiedName":"LibTmux::Filter::matches","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"record"}],"raw":"sub matches($self, $record)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":136,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-matches"},{"apiScope":"exported","doc":{"summary":"`new(entity => kind, where => $hashref)` validates the complete criteria tree and owns a normalized copy. Schemas choose comparison types; no scalar-history coercion or arbitrary method dispatch occurs. Errors throw :obj:`InvalidFilter <LibTmux::X::InvalidFilter>` with precise paths, even for unreachable branches."},"id":"LibTmux::Filter::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::new","qualifiedName":"LibTmux::Filter::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-new"},{"apiScope":"exported","doc":{"summary":"Return an independent copy of normalized Perl criteria. Editing it does not change the compiled filter."},"id":"LibTmux::Filter::normalized_where","kind":"method","modifiers":[],"name":"normalized_where","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::normalized_where","qualifiedName":"LibTmux::Filter::normalized_where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4}],"params":[],"raw":"sub normalized_where($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-normalized_where"},{"apiScope":"exported","doc":{"summary":"`register_adapter(class => name, entity => kind, readers => { field => coderef })` registers trusted field readers without inheritance. Only declared fields are accepted. Readers are executable local code; they never enter portable criteria. See :obj:`LibTmux::Schema <LibTmux::Schema>`."},"id":"LibTmux::Filter::register_adapter","kind":"method","modifiers":[],"name":"register_adapter","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::register_adapter","qualifiedName":"LibTmux::Filter::register_adapter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub register_adapter($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":20,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-register_adapter"},{"apiScope":"exported","doc":{"summary":"Return a fresh `libtmux.where/v1` envelope using canonical wire field/operator names. Normalize strings, numbers, native booleans, null, objects, and arrays by schema. Aliases are currently absent; one canonical name is encoded."},"id":"LibTmux::Filter::to_data","kind":"method","modifiers":[],"name":"to_data","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::to_data","qualifiedName":"LibTmux::Filter::to_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":301,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-to_data"},{"apiScope":"exported","doc":{"summary":"Return canonical-key UTF-8 JSON octets using [JSON::PP](https://perldoc.perl.org/5.44.0/JSON::PP). Non-UTF-8 opaque path bytes throw :obj:`UnsupportedValue <LibTmux::X::UnsupportedValue>`. This is reproducible key order, not semantic canonicalization of arbitrary Boolean trees."},"id":"LibTmux::Filter::to_json","kind":"method","modifiers":[],"name":"to_json","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::to_json","qualifiedName":"LibTmux::Filter::to_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_json($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Filter.pm","line":311,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-filter-to_json"},{"apiScope":"exported","doc":{"body":"","summary":"Executor-independent prepared command continuations"},"id":"LibTmux::Operation","kind":"class","modifiers":[],"name":"Operation","package":"LibTmux","product":"core","publicId":"LibTmux::Operation","qualifiedName":"LibTmux::Operation","signatures":[{"params":[],"raw":"package LibTmux::Operation;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation"},{"apiScope":"exported","doc":{"summary":"Recover a failure with one value or another Operation."},"id":"LibTmux::Operation::catch","kind":"method","modifiers":[],"name":"catch","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::catch","qualifiedName":"LibTmux::Operation::catch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"callback"}],"raw":"sub catch($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":33,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-catch"},{"apiScope":"exported","doc":{"summary":"`request(argv => [...], stdin => $octets, ...)` owns its input arguments. Execution is explicit through :obj:`\"run\" <LibTmux::Operation::run>`; preparation performs no I/O."},"id":"LibTmux::Operation::request","kind":"method","modifiers":[],"name":"request","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::request","qualifiedName":"LibTmux::Operation::request","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"request","variadic":"keyword"}],"raw":"sub request($class, %request)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-request"},{"apiScope":"exported","doc":{"body":"The synchronous :obj:`LibTmux::Server <LibTmux::Server>` and optional async distribution use the same preparation, codecs, and graph semantics. Core has no Future dependency.","summary":"`run($executor, $on_done, $on_fail)` supplies requests and two one-argument completion callbacks to the executor. The executor returns a cancellation hook. `run` returns a cancellation coderef suppressing further submissions. Each request settles once; the complete operation yields one value or error."},"id":"LibTmux::Operation::run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::run","qualifiedName":"LibTmux::Operation::run","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15},{"end":31,"kind":"parameter","parameter":1,"start":26},{"end":38,"kind":"parameter","parameter":2,"start":33}],"params":[{"name":"executor"},{"name":"done"},{"name":"fail"}],"raw":"sub run($self, $executor, $done, $fail)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":51,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-run"},{"apiScope":"exported","doc":{"summary":"Execute an array of Operations in order, returning one arrayref of results."},"id":"LibTmux::Operation::sequence","kind":"method","modifiers":[],"name":"sequence","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::sequence","qualifiedName":"LibTmux::Operation::sequence","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"operations"}],"raw":"sub sequence($class, $operations)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-sequence"},{"apiScope":"exported","doc":{"summary":"Compose a local transformation returning one value or another Operation. Exceptions retain their original identity."},"id":"LibTmux::Operation::then","kind":"method","modifiers":[],"name":"then","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::then","qualifiedName":"LibTmux::Operation::then","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub then($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":27,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-then"},{"apiScope":"exported","doc":{"summary":"Wrap one local value, including undef for a documented void operation."},"id":"LibTmux::Operation::value","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::value","qualifiedName":"LibTmux::Operation::value","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"value"}],"raw":"sub value($class, $value)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Operation.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-operation-value"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured pane entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Pane","kind":"class","modifiers":[],"name":"Pane","package":"LibTmux","product":"core","publicId":"LibTmux::Pane","qualifiedName":"LibTmux::Pane","signatures":[{"params":[],"raw":"package LibTmux::Pane;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::Pane::active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::active","qualifiedName":"LibTmux::Pane::active","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub active($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-active"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::current_command","kind":"method","modifiers":[],"name":"current_command","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::current_command","qualifiedName":"LibTmux::Pane::current_command","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4}],"params":[],"raw":"sub current_command($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-current_command"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Pane::current_path","kind":"method","modifiers":[],"name":"current_path","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::current_path","qualifiedName":"LibTmux::Pane::current_path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub current_path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-current_path"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::cursor_shape","kind":"method","modifiers":[],"name":"cursor_shape","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::cursor_shape","qualifiedName":"LibTmux::Pane::cursor_shape","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub cursor_shape($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-cursor_shape"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::Pane::dead","kind":"method","modifiers":[],"name":"dead","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::dead","qualifiedName":"LibTmux::Pane::dead","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub dead($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-dead"},{"apiScope":"exported","doc":{"summary":"integer or undef. Local captured data; no I/O."},"id":"LibTmux::Pane::exit_status","kind":"method","modifiers":[],"name":"exit_status","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::exit_status","qualifiedName":"LibTmux::Pane::exit_status","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub exit_status($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-exit_status"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Pane::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::generation","qualifiedName":"LibTmux::Pane::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::height","qualifiedName":"LibTmux::Pane::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::id","qualifiedName":"LibTmux::Pane::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Pane::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::identity","qualifiedName":"LibTmux::Pane::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-identity"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::index","qualifiedName":"LibTmux::Pane::index","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub index($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-index"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Pane::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::kind","qualifiedName":"LibTmux::Pane::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-kind"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::pid","qualifiedName":"LibTmux::Pane::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-pid"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Pane::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::server_id","qualifiedName":"LibTmux::Pane::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-server_id"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::title","kind":"method","modifiers":[],"name":"title","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::title","qualifiedName":"LibTmux::Pane::title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub title($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-title"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Pane::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::to_record","qualifiedName":"LibTmux::Pane::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-to_record"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::width","qualifiedName":"LibTmux::Pane::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-width"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Window <LibTmux::Window>` entity. Local captured data; no I/O."},"id":"LibTmux::Pane::window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::window","qualifiedName":"LibTmux::Pane::window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub window($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Pane.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-pane-window"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Pane <LibTmux::Pane>` handles from one server generation. Empty instances still validate against the pane schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured pane entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::PaneSelection","kind":"class","modifiers":[],"name":"PaneSelection","package":"LibTmux","product":"core","publicId":"LibTmux::PaneSelection","qualifiedName":"LibTmux::PaneSelection","signatures":[{"params":[],"raw":"package LibTmux::PaneSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/PaneSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::PaneSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::count","qualifiedName":"LibTmux::PaneSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::PaneSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::exists","qualifiedName":"LibTmux::PaneSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::PaneSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::first","qualifiedName":"LibTmux::PaneSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::PaneSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::grep","qualifiedName":"LibTmux::PaneSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::PaneSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::iterator","qualifiedName":"LibTmux::PaneSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::PaneSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::new","qualifiedName":"LibTmux::PaneSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::PaneSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::one","qualifiedName":"LibTmux::PaneSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::PaneSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::one_or_undef","qualifiedName":"LibTmux::PaneSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::PaneSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::to_array","qualifiedName":"LibTmux::PaneSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::PaneSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::where","qualifiedName":"LibTmux::PaneSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-paneselection-where"},{"apiScope":"exported","doc":{"body":"","summary":"Shared owned process-supervision boundary"},"id":"LibTmux::ProcessJob","kind":"class","modifiers":[],"name":"ProcessJob","package":"LibTmux","product":"core","publicId":"LibTmux::ProcessJob","qualifiedName":"LibTmux::ProcessJob","signatures":[{"params":[],"raw":"package LibTmux::ProcessJob;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob"},{"apiScope":"exported","doc":{"summary":"Request cleanup without blocking. Cancellation can follow dispatch and does not imply rollback or completed reaping."},"id":"LibTmux::ProcessJob::cancel","kind":"method","modifiers":[],"name":"cancel","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::cancel","qualifiedName":"LibTmux::ProcessJob::cancel","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub cancel($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":108,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-cancel"},{"apiScope":"exported","doc":{"summary":"True only after a valid supervisor result proves owned program cleanup."},"id":"LibTmux::ProcessJob::cleanup_complete","kind":"method","modifiers":[],"name":"cleanup_complete","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::cleanup_complete","qualifiedName":"LibTmux::ProcessJob::cleanup_complete","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4}],"params":[],"raw":"sub cleanup_complete($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":99,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-cleanup_complete"},{"apiScope":"exported","doc":{"summary":"Accumulate bounded result octets. Malformed or excessive data is a failure."},"id":"LibTmux::ProcessJob::consume","kind":"method","modifiers":[],"name":"consume","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::consume","qualifiedName":"LibTmux::ProcessJob::consume","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"bytes"}],"raw":"sub consume($self, $bytes)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-consume"},{"apiScope":"exported","doc":{"summary":"Decode the complete result after EOF and supervisor exit. Return one :obj:`LibTmux::CommandResult <LibTmux::CommandResult>` or throw a typed error."},"id":"LibTmux::ProcessJob::finish","kind":"method","modifiers":[],"name":"finish","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::finish","qualifiedName":"LibTmux::ProcessJob::finish","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub finish($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":128,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-finish"},{"apiScope":"exported","doc":{"summary":"Return the supervisor PID. It differs from the program PID."},"id":"LibTmux::ProcessJob::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::pid","qualifiedName":"LibTmux::ProcessJob::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":98,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-pid"},{"apiScope":"exported","doc":{"summary":"Start a supervised literal command using the same arguments as :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>`. This explicit operation performs I/O."},"id":"LibTmux::ProcessJob::start","kind":"method","modifiers":[],"name":"start","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::start","qualifiedName":"LibTmux::ProcessJob::start","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"input","variadic":"keyword"}],"raw":"sub start($class, %input)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-start"},{"apiScope":"exported","doc":{"summary":"Transfer the result pipe exactly once. Its reader owns closing that handle."},"id":"LibTmux::ProcessJob::take_result_handle","kind":"method","modifiers":[],"name":"take_result_handle","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::take_result_handle","qualifiedName":"LibTmux::ProcessJob::take_result_handle","signatures":[{"methodKind":"call","nativeSyntax":[{"end":22,"kind":"name","start":4}],"params":[],"raw":"sub take_result_handle($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":101,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-take_result_handle"},{"apiScope":"exported","doc":{"summary":"The synchronous reader/reaper. A loop-owned job refuses blocking wait. Async adapters supply a spawn/reap callback and retain jobs through EOF plus the matching exit notification. Dropping a job closes its parent guard but does not synchronously wait; owners must complete their cleanup protocol."},"id":"LibTmux::ProcessJob::wait","kind":"method","modifiers":[],"name":"wait","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::wait","qualifiedName":"LibTmux::ProcessJob::wait","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub wait($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":200,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-processjob-wait"},{"apiScope":"exported","doc":{"body":"","summary":"Explainable explicit pane acquisition"},"id":"LibTmux::QueryPlan","kind":"class","modifiers":[],"name":"QueryPlan","package":"LibTmux","product":"core","publicId":"LibTmux::QueryPlan","qualifiedName":"LibTmux::QueryPlan","signatures":[{"params":[],"raw":"package LibTmux::QueryPlan;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-queryplan"},{"apiScope":"exported","doc":{"summary":"Return the compiled :obj:`LibTmux::Filter <LibTmux::Filter>`. Its matching remains local."},"id":"LibTmux::QueryPlan::filter","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::filter","qualifiedName":"LibTmux::QueryPlan::filter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub filter($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":31,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-queryplan-filter"},{"apiScope":"exported","doc":{"summary":"Return auto, never, or require. :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` executes the plan with complete captured local evaluation. Native candidates cannot hide errors or discard matches from that captured result. Only verified complete translation qualifies for require; runtime disagreement throws :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` without assigning a cause. The optional :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` observer exposes completed comparisons."},"id":"LibTmux::QueryPlan::policy","kind":"method","modifiers":[],"name":"policy","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::policy","qualifiedName":"LibTmux::QueryPlan::policy","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub policy($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":32,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-queryplan-policy"},{"apiScope":"exported","doc":{"summary":"Describe native lowering and local residual reasons. Explanation performs no I/O and uses the support floor until connected capabilities are available."},"id":"LibTmux::QueryPlan::summary","kind":"method","modifiers":[],"name":"summary","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::summary","qualifiedName":"LibTmux::QueryPlan::summary","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub summary($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":191,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-queryplan-summary"},{"apiScope":"exported","doc":{"summary":"Return an inspectable plan with source commands, filter, policy, and reasons. The :obj:`LibTmux::Schema <LibTmux::Schema>` catalog identifies required fields and relations."},"id":"LibTmux::QueryPlan::to_data","kind":"method","modifiers":[],"name":"to_data","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::to_data","qualifiedName":"LibTmux::QueryPlan::to_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":235,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-queryplan-to_data"},{"apiScope":"exported","doc":{"body":"","summary":"Catalog and explicit record adapters"},"id":"LibTmux::Schema","kind":"class","modifiers":[],"name":"Schema","package":"LibTmux","product":"core","publicId":"LibTmux::Schema","qualifiedName":"LibTmux::Schema","signatures":[{"params":[],"raw":"package LibTmux::Schema;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Schema.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-schema"},{"apiScope":"exported","doc":{"summary":"`register_adapter(class => ..., entity => ..., readers => {...})` registers trusted callbacks for declared fields. Unknown criteria keys never become method names. Missing fields throw; nullable undef is known null."},"id":"LibTmux::Schema::register_adapter","kind":"method","modifiers":[],"name":"register_adapter","package":"LibTmux","parent":"LibTmux::Schema","product":"core","publicId":"LibTmux::Schema::register_adapter","qualifiedName":"LibTmux::Schema::register_adapter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub register_adapter($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Schema.pm","line":121,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-schema-register_adapter"},{"apiScope":"exported","doc":{"body":"\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Native array selections with fixed query returns","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Filter;\nuse List::Util qw(any first);\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $session = $server->new_session(\n            name    => 'example',\n            command => ['/bin/sleep', '120']\n        );\n        my $initial = $session->window_links->one->window->panes->one;\n        $server->split_pane(\n            pane       => $initial,\n            horizontal => true,\n            command    => ['/bin/sleep', '120']\n        );\n        my $snapshot = $server->snapshot;\n        my $panes    = $snapshot->panes->where({current_command => 'sleep'})\n            ->grep(sub ($pane) { $pane->width >= 1 });\n        die 'expected two panes' unless $panes->count == 2;\n        for my $pane ($panes->@*) {\n            say $pane->id . ' ' . $pane->current_command;\n        }\n        my $only_active = $panes->one({active => true});\n        die 'active pane unavailable' unless defined $only_active;\n        my $has_active   = any { $_->active } $panes->@*;\n        my $first_active = first { $_->active } $panes->@*;\n        die 'List::Util alternatives differ'\n            unless $has_active && $first_active->id eq $only_active->id;\n        my @ids      = map  { $_->id } $panes->@*;\n        my @positive = grep { $_->width > 0 } $panes->@*;\n        die 'ordinary Perl arrays differ' unless @ids == 2 && @positive == 2;\n        my $filter =\n            LibTmux::Filter->new(entity => 'pane', where => {active => true});\n        my $decoded = LibTmux::Filter->from_json($filter->to_json);\n        die 'wire filter changed meaning'\n            unless $panes->where($decoded)->one->id eq $only_active->id;\n        my $retained = do {\n            my $observed = $server->snapshot;\n            $observed->pane_by_id($only_active->id);\n        };\n        die 'retained graph lost a relationship'\n            unless $retained->window->panes->count == 2;\n        my $same_child = $snapshot->windows->where(\n            {panes => {-some => {-and => [{index => 0}, {index => 1}]}}});\n        my $different_children = $snapshot->windows->where(\n            {\n                -and => [\n                    {panes => {-some => {index => 0}}},\n                    {panes => {-some => {index => 1}}}\n                ]\n            }\n        );\n        die 'quantifiers conflated children'\n            unless $same_child->count == 0 && $different_children->count == 1;\n        my $where = {active => true, width => {-gte => 1}};\n        my $local = $server->query_panes(where => $where, pushdown => 'never');\n        my $verification;\n        my $native = $server->query_panes(\n            where           => $where,\n            pushdown        => 'require',\n            on_verification => sub ($report) { $verification = $report },\n        );\n        die 'native verification was not observed'\n            unless $verification->{status} eq 'agreed'\n            && $verification->{comparison} eq 'exact_ids';\n        die 'native/local disagreement'\n            unless join(',', map { $_->id } @$local) eq\n            join(',', map { $_->id } @$native);\n        say 'selection, wire, graph lifetime, quantifiers, and query: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/d9fa7c5278d243c671a29cdb00e3a911ac651bfa/examples/selection.pl"}]},"id":"LibTmux::Selection","kind":"class","modifiers":[],"name":"Selection","package":"LibTmux","product":"core","publicId":"LibTmux::Selection","qualifiedName":"LibTmux::Selection","signatures":[{"params":[],"raw":"package LibTmux::Selection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection"},{"apiScope":"exported","doc":{"body":"","summary":"Local cursor over frozen membership"},"id":"LibTmux::Selection::Iterator","kind":"class","modifiers":[],"name":"Iterator","package":"LibTmux","product":"core","publicId":"LibTmux::Selection::Iterator","qualifiedName":"LibTmux::Selection::Iterator","signatures":[{"params":[],"raw":"package LibTmux::Selection::Iterator;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection/Iterator.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-iterator-cvun"},{"apiScope":"exported","doc":{"summary":"Return the next captured entity or undef only at exhaustion. Order and multiplicity match creation-time membership. Later native selection edits do not change this traversal. A cursor is consumable; create a fresh cursor with :obj:`\"iterator\" in LibTmux::Selection <LibTmux::Selection::iterator>` to traverse again. No tmux I/O occurs."},"id":"LibTmux::Selection::Iterator::next","kind":"method","modifiers":[],"name":"next","package":"LibTmux","parent":"LibTmux::Selection::Iterator","product":"core","publicId":"LibTmux::Selection::Iterator::next","qualifiedName":"LibTmux::Selection::Iterator::next","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub next($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection/Iterator.pm","line":4,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-iterator-next"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::Selection::count","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::count","qualifiedName":"LibTmux::Selection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::Selection::exists","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::exists","qualifiedName":"LibTmux::Selection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::Selection::first","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::first","qualifiedName":"LibTmux::Selection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::Selection::grep","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::grep","qualifiedName":"LibTmux::Selection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::Selection::iterator","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::iterator","qualifiedName":"LibTmux::Selection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-iterator-2bn1"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::Selection::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::new","qualifiedName":"LibTmux::Selection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::Selection::one","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::one","qualifiedName":"LibTmux::Selection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::Selection::one_or_undef","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::one_or_undef","qualifiedName":"LibTmux::Selection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::Selection::to_array","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::to_array","qualifiedName":"LibTmux::Selection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::Selection::where","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::where","qualifiedName":"LibTmux::Selection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-selection-where"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use LibTmux::Server;\n    my $server = LibTmux::Server->new(socket_name => 'application');\n    my $snapshot = $server->snapshot;\n    my $pane = $snapshot->panes->first;\n    say $server->capture_pane(pane => $pane) if defined $pane;\n```\n\n\n## CONTRACT\n\nConstruction and planning perform no I/O. Acquisition and mutation are explicit, bounded operations. Captured :obj:`LibTmux::Snapshot <LibTmux::Snapshot>` entities retain their observed graph; mutations do not refresh them. Acquire another snapshot to observe changes. Connection settings remain owned by the server wrapper; destroying it never kills a tmux daemon. See the [orchestration guide](https://github.com/libtmux/libtmux-perl/blob/master/docs/orchestration.md).\n\nPhysical entity targets accept stable ID strings or generation-checked handles. Session-relative window operations require :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`. Checks across subprocesses are optimistic rather than transactional. Single-quote session IDs such as `'$1'` to avoid interpolating a Perl capture variable.\n\n\n## ERRORS\n\nInvalid arguments throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` before dispatch. Acquisition and checked commands propagate typed :obj:`LibTmux::X <LibTmux::X>` failures, including missing executables, absent daemons, vanished targets, stale handles, codec errors, timeouts, and output limits. Failures never become empty selections. Cancellation or a timeout after dispatch does not prove nonexecution or roll back effects.\n\n\n## VERIFICATION REPORT\n\n:obj:`\"query_panes\" <LibTmux::Server::query_panes>` supplies a fresh, detached hashref to `on_verification`. It contains no entity handles. Every ID array retains stable order; editing the report cannot mutate captured data or the query result.\n\n`policy`, `status`, `comparison`Policy is auto, never, require, or native for the expert escape hatch. Status is disabled (never), local (no safe lowering), agreed, disagreed, or native. Comparison is none, exact_ids, candidate_superset, or captured_membership. Partial lowering checks inclusion of local matches; expert queries check only membership in the captured graph. Neither establishes full filter equivalence.`native_checked`, `translation_exact`, `native_filter`, `reasons`native_checked is Boolean. translation_exact is Boolean, or undef for never and expert queries. native_filter is the executed expression, or undef when no native check ran. reasons is a fresh arrayref of lowering limitations. Exact translation and agreement between two observations are separate facts.`server_id`, `generation`, `daemon_version`, `capture_start`, `capture_end`Identity strings and the captured interval in wall-clock seconds since the epoch, from :obj:`\"metadata\" in LibTmux::Snapshot <LibTmux::Snapshot::metadata>`. This is not an atomic observation.`captured_ids`, `local_ids`, `native_ids`captured_ids and local_ids follow physical capture order; local_ids is undef for expert queries. native_ids holds unique IDs in native first-occurrence order, or undef when no check ran. An empty array is an observed empty set.`missing_ids`, `unexpected_ids`, `uncaptured_ids`missing_ids lists local matches absent natively, in local order. For exact lowering, unexpected_ids lists native matches absent locally. uncaptured_ids lists native IDs absent from the graph. The latter two follow native order; inapplicable lists are empty. Any applicable mismatch produces disagreed. :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` carries this report for require or expert failures; the observer is not called for a failed query. A discrepancy has no inferred cause: concurrent changes, compiler defects and backend differences all need investigation.\n\n","summary":"Explicit tmux acquisition and commands","examples":[{"lang":"perl","code":"use v5.44;\nuse Config;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\n\n# This complete demo owns a Linux child-reaping scope, including tmux panes.\nBEGIN {\n    die 'Requires Linux x86_64 LP64'\n        unless $^O eq 'linux'\n        && $Config::Config{archname} =~ /x86_64/\n        && $Config::Config{ptrsize} == 8\n        && $Config::Config{ivsize} == 8;\n    syscall(157, 36, 1, 0, 0, 0) == 0 or die \"subreaper: $!\";\n}\n\ntry {\n    LibTmuxFixture->run(\n        sub ($server, $root) {\n            my $session = $server->new_session(\n                name    => 'demo',\n                command => ['/bin/cat']\n            );\n            my $failure;\n            try {\n                my $editor = $session->window_links->one->window;\n                $server->rename_window(window => $editor, name => 'editor');\n                my $right = $server->split_pane(\n                    pane       => $editor->panes->one,\n                    horizontal => true,\n                    command    => ['/bin/cat']\n                );\n                my $logs = $server->new_window(\n                    session => $session,\n                    name    => 'logs',\n                    command => ['/bin/cat']\n                );\n                $server->select_pane(pane => $right);\n                my $snapshot = $server->snapshot;\n                my $link     = $snapshot->window_links->one(\n                    {\n                        window => {-is => {id => $logs->id}}\n                    }\n                );\n                $server->select_window(link => $link);\n                $snapshot = $server->snapshot;\n\n                for my $entry ($snapshot->sessions->@*) {\n                    say 'session ', $entry->name;\n                    for my $link ($entry->window_links->@*) {\n                        my $window = $link->window;\n                        my $ids   = join ' ', map { $_->id } $window->panes->@*;\n                        my $label = $link->index . ':' . $window->name;\n                        say '  window ', $label, ': ', $ids;\n                    }\n                }\n                my $panes =\n                    $snapshot->windows->one({name => 'editor'})\n                    ->panes->where({width => {-gte => 1}})\n                    ->grep(sub ($pane) { $pane->height >= 1 });\n                my $selected = $panes->one({active => true});\n                die 'unexpected pane membership' unless $panes->count == 2;\n                my $name = $selected->window->name;\n                say $selected->id, ' is in window ', $name;\n            }\n            catch ($error) { $failure = $error }\n            $server->kill_session(session => $session);\n            die $failure if defined $failure;\n        }\n    );\n}\ncatch ($error) {\n    warn \"tmux quickstart failed: $error\\n\";\n    die $error;\n}\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/d9fa7c5278d243c671a29cdb00e3a911ac651bfa/examples/quickstart.pl"}]},"id":"LibTmux::Server","kind":"class","modifiers":[],"name":"Server","package":"LibTmux","product":"core","publicId":"LibTmux::Server","qualifiedName":"LibTmux::Server","signatures":[{"params":[],"raw":"package LibTmux::Server;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server"},{"apiScope":"exported","doc":{"body":"Return a fresh literal argument array for a caller-owned interactive terminal without I/O. The session target is a stable ID string; obtain it through :obj:`\"id\" in LibTmux::Session <LibTmux::Session::id>`. The caller owns terminal/process setup and exit observation; the bounded capture transport does not allocate a TTY. Invalid inputs throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>`.\n\n\n```perl\n    my $argv = $server->attach_argv(session => '$1');\n```","summary":"`attach_argv(session => session_id)`."},"id":"LibTmux::Server::attach_argv","kind":"method","modifiers":[],"name":"attach_argv","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::attach_argv","qualifiedName":"LibTmux::Server::attach_argv","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub attach_argv($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":978,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-attach_argv"},{"apiScope":"exported","doc":{"body":"Perform ordered independent literal requests and return a fresh array reference of {result, error} records in input order. Each result is :obj:`LibTmux::CommandResult <LibTmux::CommandResult>` or undef; each dispatch error is the original typed :obj:`LibTmux::X <LibTmux::X>` or undef. Nonzero command exits stay raw results. An empty input returns an empty array without command I/O. Requests are attempted in order, without rollback or tmux command-list attribution.\n\n\n```perl\n    my $results = $server->batch([['display-message', '-p', '#{version}']]);\n```","summary":"`batch(arrayref_of_argv)`."},"id":"LibTmux::Server::batch","kind":"method","modifiers":[],"name":"batch","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::batch","qualifiedName":"LibTmux::Server::batch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"requests"}],"raw":"sub batch($self, $requests)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":974,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-batch"},{"apiScope":"exported","doc":{"body":"Read a :obj:`LibTmux::Pane <LibTmux::Pane>` and return raw terminal octets, including tmux's final newline. Optional start/end select native history rows; no UTF-8 replacement is performed. This I/O reads current observed content without waiting for application work. Command/transport failures propagate through :obj:`LibTmux::X <LibTmux::X>`.\n\n\n```perl\n    my $bytes = $server->capture_pane(pane => $pane, start => -20);\n```","summary":"`capture_pane(pane => Pane|pane_id, start => integer?, end => integer?)`."},"id":"LibTmux::Server::capture_pane","kind":"method","modifiers":[],"name":"capture_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::capture_pane","qualifiedName":"LibTmux::Server::capture_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub capture_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1058,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-capture_pane"},{"apiScope":"exported","doc":{"body":"Acquire a graph and return its :obj:`LibTmux::ClientSelection <LibTmux::ClientSelection>`. A daemon without attached clients produces an empty selection. Membership is copied away from graph storage. Acquisition failures propagate through :obj:`LibTmux::X <LibTmux::X>`; :obj:`\"detach_client\" <LibTmux::Server::detach_client>` changes client state explicitly.\n\n\n```perl\n    my $clients = $server->clients;\n```","summary":"`clients()`."},"id":"LibTmux::Server::clients","kind":"method","modifiers":[],"name":"clients","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::clients","qualifiedName":"LibTmux::Server::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub clients($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1077,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-clients"},{"apiScope":"exported","doc":{"body":"Perform one checked literal tmux command and return :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`. No shell wrapper or implicit tmux command list is used. Nonzero exits throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>` or a more specific target/server error; transport failures propagate.\n\n\n```perl\n    my $result = $server->cmd('display-message', '-p', '#{version}');\n```","summary":"`cmd(@literal_arguments)`."},"id":"LibTmux::Server::cmd","kind":"method","modifiers":[],"name":"cmd","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::cmd","qualifiedName":"LibTmux::Server::cmd","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":20,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"argv","variadic":"positional"}],"raw":"sub cmd($self, @argv)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":968,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-cmd"},{"apiScope":"exported","doc":{"body":"Delete the named daemon buffer loaded through :obj:`\"set_buffer\" <LibTmux::Server::set_buffer>`. Other daemon buffers remain untouched; later :obj:`\"show_buffer\" <LibTmux::Server::show_buffer>` calls report absence as a command failure.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->delete_buffer(name => 'application');\n```","summary":"`delete_buffer(name => string)`."},"id":"LibTmux::Server::delete_buffer","kind":"method","modifiers":[],"name":"delete_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::delete_buffer","qualifiedName":"LibTmux::Server::delete_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub delete_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-delete_buffer"},{"apiScope":"exported","doc":{"body":"Request detachment of a captured :obj:`LibTmux::Client <LibTmux::Client>` or explicit native client name. Command acceptance can precede client-process exit; callers owning an attached process must observe its exit separately.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->detach_client(client => $client);\n```","summary":"`detach_client(client => Client|client_name)`."},"id":"LibTmux::Server::detach_client","kind":"method","modifiers":[],"name":"detach_client","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::detach_client","qualifiedName":"LibTmux::Server::detach_client","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub detach_client($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1079,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-detach_client"},{"apiScope":"exported","doc":{"body":"Perform one raw command and return :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, including nonzero exits. stdout and stderr remain separate octet strings. stdin is optional bytes; cancel_fh is borrowed and remains open. Transport failures throw typed :obj:`LibTmux::X <LibTmux::X>` with bounded partial output when available.\n\n\n```perl\n    my $result = $server->execute(argv => ['list-sessions']);\n```","summary":"`execute(argv => arrayref, stdin => bytes?, timeout => seconds?, cancel_fh => handle?)`."},"id":"LibTmux::Server::execute","kind":"method","modifiers":[],"name":"execute","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::execute","qualifiedName":"LibTmux::Server::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub execute($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":987,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-execute"},{"apiScope":"exported","doc":{"body":"Validate criteria and return an inspectable :obj:`LibTmux::QueryPlan <LibTmux::QueryPlan>` without I/O or mutation. The plan records required fields/relations, source commands, residuals, and conditional daemon capability needs. Invalid criteria throw :obj:`\"InvalidFilter\" in LibTmux::X <LibTmux::X::InvalidFilter>`. Executing :obj:`\"query_panes\" <LibTmux::Server::query_panes>` discovers the connected generation and capabilities.\n\n\n```perl\n    my $plan = $server->explain_panes(where => {width => {-gte => 120}});\n```","summary":"`explain_panes(where => criteria|Filter, pushdown => policy?)`."},"id":"LibTmux::Server::explain_panes","kind":"method","modifiers":[],"name":"explain_panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::explain_panes","qualifiedName":"LibTmux::Server::explain_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub explain_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1006,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-explain_panes"},{"apiScope":"exported","doc":{"body":"Read a session/global variable and return its octets. The native quoted representation is parsed as data; no shell evaluates it. Literal backslashes, newlines and non-UTF-8 bytes remain distinct. Empty text and '0' remain values. Performs I/O without mutation; missing or explicitly unset variables throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`, and malformed output throws :obj:`\"Codec\" in LibTmux::X <LibTmux::X::Codec>`. Captured targets follow :obj:`\"set_environment\" <LibTmux::Server::set_environment>`'s generation checks.\n\n\n```perl\n    my $value = $server->get_environment(session => $session, name => 'BUILD');\n```","summary":"`get_environment(name => env_name, session => session_target?)`."},"id":"LibTmux::Server::get_environment","kind":"method","modifiers":[],"name":"get_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::get_environment","qualifiedName":"LibTmux::Server::get_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1104,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-get_environment"},{"apiScope":"exported","doc":{"body":"Read an option and return its octets, decoding tmux's quoted string values. Literal backslashes and non-UTF-8 bytes remain distinct on older daemons. Key, numeric and command options retain native printed syntax. Array values are joined with newlines in native index order; an empty array returns `''`. Empty text and '0' remain values. `inherited => true` requests tmux's `-A` behavior; otherwise only the selected local level is queried. Performs I/O without mutation. Native missing-option errors throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`; malformed output throws :obj:`\"Codec\" in LibTmux::X <LibTmux::X::Codec>`. A built-in option without a local override may produce empty output. See :obj:`\"set_option\" <LibTmux::Server::set_option>` and :obj:`\"unset_option\" <LibTmux::Server::unset_option>`.\n\n\n```perl\n    my $value = $server->get_option(scope => 'window', target => $window->id, name => '@build');\n```","summary":"`get_option(name => string, scope => scope, target => id?, global => boolean?, inherited => boolean?)`."},"id":"LibTmux::Server::get_option","kind":"method","modifiers":[],"name":"get_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::get_option","qualifiedName":"LibTmux::Server::get_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1087,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-get_option"},{"apiScope":"exported","doc":{"body":"Destroy the selected :obj:`LibTmux::Pane <LibTmux::Pane>`. Killing a window's final pane may destroy the physical window and its :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` associations. Previously captured records remain readable observations.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_pane(pane => $pane);\n```","summary":"`kill_pane(pane => Pane|pane_id)`."},"id":"LibTmux::Server::kill_pane","kind":"method","modifiers":[],"name":"kill_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_pane","qualifiedName":"LibTmux::Server::kill_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1062,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-kill_pane"},{"apiScope":"exported","doc":{"body":"Explicitly request destruction of the connected tmux daemon. This method can affect a borrowed server and must be called intentionally; wrapper destruction never calls it. Successful command acceptance alone does not prove every daemon/client process exited.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_server;\n```","summary":"`kill_server()`."},"id":"LibTmux::Server::kill_server","kind":"method","modifiers":[],"name":"kill_server","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_server","qualifiedName":"LibTmux::Server::kill_server","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_server($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1074,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-kill_server"},{"apiScope":"exported","doc":{"body":"Destroy the selected :obj:`LibTmux::Session <LibTmux::Session>` and its links. Windows linked elsewhere can survive. Captured data remains local; later mutations through stale generation handles are checked.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_session(session => $session);\n```","summary":"`kill_session(session => Session|session_id)`."},"id":"LibTmux::Server::kill_session","kind":"method","modifiers":[],"name":"kill_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_session","qualifiedName":"LibTmux::Server::kill_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1070,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-kill_session"},{"apiScope":"exported","doc":{"body":"Destroy the physical :obj:`LibTmux::Window <LibTmux::Window>` and every :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` referring to it. Use :obj:`\"unlink_window\" <LibTmux::Server::unlink_window>` when removing one association is the intended effect.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_window(window => $window);\n```","summary":"`kill_window(window => Window|window_id)`."},"id":"LibTmux::Server::kill_window","kind":"method","modifiers":[],"name":"kill_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_window","qualifiedName":"LibTmux::Server::kill_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1066,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-kill_window"},{"apiScope":"exported","doc":{"body":"Add an association from a physical :obj:`LibTmux::Window <LibTmux::Window>` to a :obj:`LibTmux::Session <LibTmux::Session>`. index is optional; conflicts remain command failures. Existing associations are preserved. Inspect new :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` records through :obj:`\"snapshot\" <LibTmux::Server::snapshot>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->link_window(window => $window, session => $session, index => 4);\n```","summary":"`link_window(window => Window|window_id, session => Session|session_id, index => integer?)`."},"id":"LibTmux::Server::link_window","kind":"method","modifiers":[],"name":"link_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::link_window","qualifiedName":"LibTmux::Server::link_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub link_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1018,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-link_window"},{"apiScope":"exported","doc":{"body":"Perform acquisition and return a fresh unblessed array reference of contextual hash records in tmux order, preserving duplicate physical identities. kind is session, window, pane, or client. An attached-client listing can be empty. Records are detached values; :obj:`\"snapshot\" <LibTmux::Server::snapshot>` normalizes the graph. Acquisition/codec failures propagate through :obj:`LibTmux::X <LibTmux::X>`.\n\n\n```perl\n    my $rows = $server->listings('window');\n```","summary":"`listings(kind)`."},"id":"LibTmux::Server::listings","kind":"method","modifiers":[],"name":"listings","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::listings","qualifiedName":"LibTmux::Server::listings","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"kind"}],"raw":"sub listings($self, $kind)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":970,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-listings"},{"apiScope":"exported","doc":{"body":"Move one contextual :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` into the destination session/index. Other links of the physical window keep their own associations. Use :obj:`\"link_window\" <LibTmux::Server::link_window>` to add an association without moving one.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->move_window(link => $link, session => $session, index => 4);\n```","summary":"`move_window(link => WindowLink|session_id:index, session => Session|session_id, index => integer?)`."},"id":"LibTmux::Server::move_window","kind":"method","modifiers":[],"name":"move_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::move_window","qualifiedName":"LibTmux::Server::move_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub move_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1026,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-move_window"},{"apiScope":"exported","doc":{"body":"Return a new server wrapper without I/O. Select socket_name or socket_path, never both. Defaults are executable tmux, timeout 5 seconds, and an 8 MiB combined retained-output limit. env is copied; child processes clear ambient TMUX and TMUX_PANE. Invalid configuration throws :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>`.\n\n\n```perl\n    my $server = LibTmux::Server->new(socket_name => 'application');\n```","summary":"`new(executable => tmux, socket_name|socket_path => string, timeout => seconds, max_output => bytes, config_file => path, env => hashref)`."},"id":"LibTmux::Server::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new","qualifiedName":"LibTmux::Server::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-new"},{"apiScope":"exported","doc":{"body":"Create a detached session and return its captured :obj:`LibTmux::Session <LibTmux::Session>`. command is a literal argument vector; shell_command explicitly requests a shell and is mutually exclusive. Omitting both uses tmux's default command. cwd is path octets; environment supplies NAME/value pairs to the first process. Performs I/O. If creation succeeds but acquisition fails, :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` retains the known generation-scoped creation receipt and cause.\n\n\n```perl\n    my $session = $server->new_session(name => 'application', command => ['/bin/cat']);\n```","summary":"`new_session(name => string, command => arrayref?, shell_command => string?, width => integer?, height => integer?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::new_session","kind":"method","modifiers":[],"name":"new_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new_session","qualifiedName":"LibTmux::Server::new_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":989,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-new_session"},{"apiScope":"exported","doc":{"body":"Create a detached physical window in the selected session and return its captured :obj:`LibTmux::Window <LibTmux::Window>`. command, shell_command, cwd, and environment follow :obj:`\"new_session\" <LibTmux::Server::new_session>`. The new link uses tmux's next available index. Performs I/O; :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` preserves known effects if subsequent acquisition fails.\n\n\n```perl\n    my $window = $server->new_window(session => $session, name => 'logs', command => ['/bin/cat']);\n```","summary":"`new_window(session => Session|session_id, name => string?, command => arrayref?, shell_command => string?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::new_window","kind":"method","modifiers":[],"name":"new_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new_window","qualifiedName":"LibTmux::Server::new_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":993,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-new_window"},{"apiScope":"exported","doc":{"body":"```perl\n    my $operation = $server->operation('snapshot');\n```","summary":"`operation($name, %arguments)` validates and copies arguments, returning one :obj:`LibTmux::Operation <LibTmux::Operation>` without I/O. The optional Future facade shares this preparation and parsing boundary. Use the named methods above for synchronous execution. Invalid arguments or criteria throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` or :obj:`\"InvalidFilter\" in LibTmux::X <LibTmux::X::InvalidFilter>` before submission."},"id":"LibTmux::Server::operation","kind":"method","modifiers":[],"name":"operation","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::operation","qualifiedName":"LibTmux::Server::operation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21},{"end":33,"kind":"parameter","parameter":1,"start":28}],"params":[{"name":"name"},{"name":"args","variadic":"keyword"}],"raw":"sub operation($self, $name, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":854,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-operation"},{"apiScope":"exported","doc":{"body":"Acquire and return a new :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>` in captured physical-pane order. where accepts a hash reference or :obj:`LibTmux::Filter <LibTmux::Filter>`. auto verifies safe scalar candidates after complete local evaluation; never disables the native comparison. The default auto costs one extra command and supervisor when lowering is available; it does not reduce acquisition. Select never when only the captured answer is needed. require throws :obj:`\"Unsupported\" in LibTmux::X <LibTmux::X::Unsupported>` unless lowering is exact, or :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` on disagreement. native_filter is an exclusive expert escape hatch. Empty successful matches remain a typed selection; acquisition/evaluation failures propagate.\n\n`on_verification` receives one detached report hashref in void context after a successful decision, including auto fallback. It runs inline once; its return is ignored and exceptions propagate unchanged unless the operation has already been cancelled. Cancellation suppresses subsequent result/error delivery. Failed queries do not invoke it. Report edits cannot change the returned selection. See :obj:`\"VERIFICATION REPORT\" <LibTmux::Server#VERIFICATION%20REPORT>` and :obj:`\"explain_panes\" <LibTmux::Server::explain_panes>`.\n\n\n```perl\n    my $panes = $server->query_panes(where => {active => true}, pushdown => 'auto');\n```","summary":"`query_panes(where => criteria|Filter?, pushdown => auto|never|require?, native_filter => string?, on_verification => coderef?)`."},"id":"LibTmux::Server::query_panes","kind":"method","modifiers":[],"name":"query_panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::query_panes","qualifiedName":"LibTmux::Server::query_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub query_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1002,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-query_panes"},{"apiScope":"exported","doc":{"body":"Rename the selected :obj:`LibTmux::Session <LibTmux::Session>` using a literal name. Existing captured handles keep the old observed name; use :obj:`\"snapshot\" <LibTmux::Server::snapshot>` to observe the change.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->rename_session(session => $session, name => 'application');\n```","summary":"`rename_session(session => Session|session_id, name => string)`."},"id":"LibTmux::Server::rename_session","kind":"method","modifiers":[],"name":"rename_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::rename_session","qualifiedName":"LibTmux::Server::rename_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":18,"kind":"name","start":4},{"end":31,"kind":"parameter","parameter":0,"start":26}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1010,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-rename_session"},{"apiScope":"exported","doc":{"body":"Rename the physical :obj:`LibTmux::Window <LibTmux::Window>` across all its links. Names remain literal rather than expanding tmux formats. Captured handles keep their observed name.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->rename_window(window => $window, name => 'logs');\n```","summary":"`rename_window(window => Window|window_id, name => string)`."},"id":"LibTmux::Server::rename_window","kind":"method","modifiers":[],"name":"rename_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::rename_window","qualifiedName":"LibTmux::Server::rename_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1014,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-rename_window"},{"apiScope":"exported","doc":{"body":"Resize a :obj:`LibTmux::Pane <LibTmux::Pane>` to the supplied positive width and/or height. tmux's layout constraints may affect the resulting dimensions; inspect another :obj:`LibTmux::Snapshot <LibTmux::Snapshot>` for observed values.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->resize_pane(pane => $pane, width => 100);\n```","summary":"`resize_pane(pane => Pane|pane_id, width => positive_integer?, height => positive_integer?)`."},"id":"LibTmux::Server::resize_pane","kind":"method","modifiers":[],"name":"resize_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::resize_pane","qualifiedName":"LibTmux::Server::resize_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub resize_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1042,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-resize_pane"},{"apiScope":"exported","doc":{"body":"Apply an unambiguous predefined layout name or a checksum-prefixed native layout to a :obj:`LibTmux::Window <LibTmux::Window>`. Unknown or ambiguous predefined names throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` before dispatch, including on tmux 3.3a. Native custom-layout validation remains tmux's responsibility.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_layout(window => $window, layout => 'tiled');\n```","summary":"`select_layout(window => Window|window_id, layout => string)`."},"id":"LibTmux::Server::select_layout","kind":"method","modifiers":[],"name":"select_layout","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_layout","qualifiedName":"LibTmux::Server::select_layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_layout($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1038,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-select_layout"},{"apiScope":"exported","doc":{"body":"Change the active :obj:`LibTmux::Pane <LibTmux::Pane>` of its physical window. This differs from selecting a session's :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_pane(pane => $pane);\n```","summary":"`select_pane(pane => Pane|pane_id)`."},"id":"LibTmux::Server::select_pane","kind":"method","modifiers":[],"name":"select_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_pane","qualifiedName":"LibTmux::Server::select_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1034,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-select_pane"},{"apiScope":"exported","doc":{"body":"Select a :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` within its session. A physical window alone cannot identify session-relative active state. Capture again through :obj:`\"snapshot\" <LibTmux::Server::snapshot>` to observe the selected link.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_window(link => $link);\n```","summary":"`select_window(link => WindowLink|session_id:index)`."},"id":"LibTmux::Server::select_window","kind":"method","modifiers":[],"name":"select_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_window","qualifiedName":"LibTmux::Server::select_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1030,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-select_window"},{"apiScope":"exported","doc":{"body":"Send the array's named keys in order to a :obj:`LibTmux::Pane <LibTmux::Pane>`. tmux interprets key names; arguments beginning with a dash remain key operands. An empty array sends no keys. Acceptance does not prove the pane application consumed input. Use :obj:`\"send_text\" <LibTmux::Server::send_text>` for literal text.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->send_keys(pane => $pane, keys => ['Enter']);\n```","summary":"`send_keys(pane => Pane|pane_id, keys => arrayref)`."},"id":"LibTmux::Server::send_keys","kind":"method","modifiers":[],"name":"send_keys","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::send_keys","qualifiedName":"LibTmux::Server::send_keys","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_keys($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1050,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-send_keys"},{"apiScope":"exported","doc":{"body":"Send literal text/bytes to a :obj:`LibTmux::Pane <LibTmux::Pane>`, then optionally send Enter. Empty text is permitted. Acceptance does not prove application completion. Use an application-specific observable handshake before relying on output; :obj:`\"capture_pane\" <LibTmux::Server::capture_pane>` reads observed terminal content.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->send_text(pane => $pane, text => 'hello', enter => true);\n```","summary":"`send_text(pane => Pane|pane_id, text => string|bytes, enter => boolean?)`."},"id":"LibTmux::Server::send_text","kind":"method","modifiers":[],"name":"send_text","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::send_text","qualifiedName":"LibTmux::Server::send_text","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_text($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1054,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-send_text"},{"apiScope":"exported","doc":{"body":"Load a named tmux buffer through stdin bytes rather than interpolating data into a command. Empty data is permitted. :obj:`\"show_buffer\" <LibTmux::Server::show_buffer>` retrieves bytes; buffer ownership remains in the daemon until :obj:`\"delete_buffer\" <LibTmux::Server::delete_buffer>` or an external change.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_buffer(name => 'application', data => \"a\\0b\");\n```","summary":"`set_buffer(name => string, data => bytes)`."},"id":"LibTmux::Server::set_buffer","kind":"method","modifiers":[],"name":"set_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_buffer","qualifiedName":"LibTmux::Server::set_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1112,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-set_buffer"},{"apiScope":"exported","doc":{"body":"Set a literal environment value for a :obj:`LibTmux::Session <LibTmux::Session>` handle or explicit session ID, or globally when session is omitted. Empty text and '0' remain values. Existing pane processes are unaffected; creation-time environment belongs to :obj:`\"new_session\" <LibTmux::Server::new_session>`, :obj:`\"new_window\" <LibTmux::Server::new_window>`, and :obj:`\"split_pane\" <LibTmux::Server::split_pane>`. Captured handles are checked against the connected daemon generation before dispatch; stale handles throw :obj:`\"StaleReference\" in LibTmux::X <LibTmux::X::StaleReference>`. Raw IDs target the current session. The probe and mutation remain separate operations.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_environment(session => $session, name => 'BUILD', value => '0');\n```","summary":"`set_environment(name => env_name, value => bytes, session => session_target?)`."},"id":"LibTmux::Server::set_environment","kind":"method","modifiers":[],"name":"set_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_environment","qualifiedName":"LibTmux::Server::set_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1100,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-set_environment"},{"apiScope":"exported","doc":{"body":"Set a native hook or sparse hook[index] entry for an explicit session target or global scope. command is deliberately a tmux command string, unlike literal process argv. :obj:`\"show_hooks\" <LibTmux::Server::show_hooks>` preserves native indexes/quoting rather than inventing a flattened hook list.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_hook(target => $session->id, name => 'after-select-window[3]', command => 'display-message hook');\n```","summary":"`set_hook(name => hook_or_hook[index], command => explicit_tmux_command_string, target => session_id?, global => boolean?)`."},"id":"LibTmux::Server::set_hook","kind":"method","modifiers":[],"name":"set_hook","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_hook","qualifiedName":"LibTmux::Server::set_hook","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_hook($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1094,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-set_hook"},{"apiScope":"exported","doc":{"body":"Set an option at explicit session/window/pane/server scope. Supply an exact target ID for local settings or global => true for the global level. Empty and zero values are preserved. :obj:`\"get_option\" <LibTmux::Server::get_option>` controls whether inherited values participate.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_option(scope => 'window', target => $window->id, name => '@build', value => '0');\n```","summary":"`set_option(name => string, value => string|integer, scope => session|window|pane|server, target => id?, global => boolean?)`."},"id":"LibTmux::Server::set_option","kind":"method","modifiers":[],"name":"set_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_option","qualifiedName":"LibTmux::Server::set_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1083,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-set_option"},{"apiScope":"exported","doc":{"body":"Set a :obj:`LibTmux::Pane <LibTmux::Pane>` title. Literal input is protected from format expansion; tmux's own title sanitization remains observable in a new :obj:`LibTmux::Snapshot <LibTmux::Snapshot>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_title(pane => $pane, title => 'build.v2');\n```","summary":"`set_title(pane => Pane|pane_id, title => string)`."},"id":"LibTmux::Server::set_title","kind":"method","modifiers":[],"name":"set_title","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_title","qualifiedName":"LibTmux::Server::set_title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_title($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1046,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-set_title"},{"apiScope":"exported","doc":{"body":"Read a named tmux buffer and return raw octets, including embedded NUL bytes. Empty data remains an empty string. Performs I/O; a missing buffer throws :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`. See :obj:`\"set_buffer\" <LibTmux::Server::set_buffer>`.\n\n\n```perl\n    my $bytes = $server->show_buffer(name => 'application');\n```","summary":"`show_buffer(name => string)`."},"id":"LibTmux::Server::show_buffer","kind":"method","modifiers":[],"name":"show_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::show_buffer","qualifiedName":"LibTmux::Server::show_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1116,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-show_buffer"},{"apiScope":"exported","doc":{"body":"Read hooks and return raw octets preserving sparse indexes and tmux quoting. No hooks produce empty text. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. See :obj:`\"set_hook\" <LibTmux::Server::set_hook>` for explicit command-string semantics.\n\n\n```perl\n    my $hooks = $server->show_hooks(target => $session->id);\n```","summary":"`show_hooks(target => session_id?, global => boolean?)`."},"id":"LibTmux::Server::show_hooks","kind":"method","modifiers":[],"name":"show_hooks","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::show_hooks","qualifiedName":"LibTmux::Server::show_hooks","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_hooks($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1096,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-show_hooks"},{"apiScope":"exported","doc":{"body":"Perform strict graph acquisition and return :obj:`LibTmux::Snapshot <LibTmux::Snapshot>`. Physical windows/panes appear once; :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` retains each contextual association. Capture start/end describe an observation interval, not an atomic transaction. Acquisition, unsupported capabilities, and incomplete topology throw typed :obj:`LibTmux::X <LibTmux::X>`; no partial snapshot is returned.\n\n\n```perl\n    my $snapshot = $server->snapshot;\n```","summary":"`snapshot()`."},"id":"LibTmux::Server::snapshot","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::snapshot","qualifiedName":"LibTmux::Server::snapshot","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub snapshot($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1000,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-snapshot"},{"apiScope":"exported","doc":{"body":"Split the targeted pane and return the new captured :obj:`LibTmux::Pane <LibTmux::Pane>`. horizontal selects side-by-side placement; false uses tmux's vertical split. command, shell_command, cwd, and environment follow :obj:`\"new_session\" <LibTmux::Server::new_session>`. Performs I/O; creation/acquisition failures follow :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>`.\n\n\n```perl\n    my $other = $server->split_pane(pane => $pane, horizontal => true, command => ['/bin/cat']);\n```","summary":"`split_pane(pane => Pane|pane_id, horizontal => boolean?, command => arrayref?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::split_pane","kind":"method","modifiers":[],"name":"split_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::split_pane","qualifiedName":"LibTmux::Server::split_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub split_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":997,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-split_pane"},{"apiScope":"exported","doc":{"body":"Remove exactly one :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, given a captured link or session_id:index string. Removing the final link can destroy its physical window; other linked associations retain their context.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unlink_window(link => $link);\n```","summary":"`unlink_window(link => WindowLink|session_id:index)`."},"id":"LibTmux::Server::unlink_window","kind":"method","modifiers":[],"name":"unlink_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unlink_window","qualifiedName":"LibTmux::Server::unlink_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unlink_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1022,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-unlink_window"},{"apiScope":"exported","doc":{"body":"Unset the named session/global variable. This differs from setting an empty value; :obj:`\"get_environment\" <LibTmux::Server::get_environment>` reports the unset state as a command error.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unset_environment(session => $session, name => 'BUILD');\n```","summary":"`unset_environment(name => env_name, session => session_target?)`."},"id":"LibTmux::Server::unset_environment","kind":"method","modifiers":[],"name":"unset_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unset_environment","qualifiedName":"LibTmux::Server::unset_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":21,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1108,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-unset_environment"},{"apiScope":"exported","doc":{"body":"Remove the selected local/global option so inheritance can take effect. Scope and target follow :obj:`\"set_option\" <LibTmux::Server::set_option>`; removing an override differs from assigning empty text.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unset_option(scope => 'window', target => $window->id, name => '@build');\n```","summary":"`unset_option(name => string, scope => scope, target => id?, global => boolean?)`."},"id":"LibTmux::Server::unset_option","kind":"method","modifiers":[],"name":"unset_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unset_option","qualifiedName":"LibTmux::Server::unset_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Server.pm","line":1091,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-server-unset_option"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured session entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Session","kind":"class","modifiers":[],"name":"Session","package":"LibTmux","product":"core","publicId":"LibTmux::Session","qualifiedName":"LibTmux::Session","signatures":[{"params":[],"raw":"package LibTmux::Session;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Session::attached","kind":"method","modifiers":[],"name":"attached","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::attached","qualifiedName":"LibTmux::Session::attached","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub attached($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-attached"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Session::created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::created","qualifiedName":"LibTmux::Session::created","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub created($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-created"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Session::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::generation","qualifiedName":"LibTmux::Session::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-generation"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Session::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::id","qualifiedName":"LibTmux::Session::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Session::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::identity","qualifiedName":"LibTmux::Session::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Session::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::kind","qualifiedName":"LibTmux::Session::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Session::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::name","qualifiedName":"LibTmux::Session::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-name"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Session::path","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::path","qualifiedName":"LibTmux::Session::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-path"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Session::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::server_id","qualifiedName":"LibTmux::Session::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Session::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::to_record","qualifiedName":"LibTmux::Session::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-to_record"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` entities. Local captured data; no I/O."},"id":"LibTmux::Session::window_links","kind":"method","modifiers":[],"name":"window_links","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::window_links","qualifiedName":"LibTmux::Session::window_links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub window_links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Session.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-session-window_links"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Session <LibTmux::Session>` handles from one server generation. Empty instances still validate against the session schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured session entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::SessionSelection","kind":"class","modifiers":[],"name":"SessionSelection","package":"LibTmux","product":"core","publicId":"LibTmux::SessionSelection","qualifiedName":"LibTmux::SessionSelection","signatures":[{"params":[],"raw":"package LibTmux::SessionSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/SessionSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::SessionSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::count","qualifiedName":"LibTmux::SessionSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::SessionSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::exists","qualifiedName":"LibTmux::SessionSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::SessionSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::first","qualifiedName":"LibTmux::SessionSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::SessionSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::grep","qualifiedName":"LibTmux::SessionSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::SessionSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::iterator","qualifiedName":"LibTmux::SessionSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::SessionSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::new","qualifiedName":"LibTmux::SessionSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::SessionSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::one","qualifiedName":"LibTmux::SessionSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::SessionSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::one_or_undef","qualifiedName":"LibTmux::SessionSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::SessionSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::to_array","qualifiedName":"LibTmux::SessionSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::SessionSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::where","qualifiedName":"LibTmux::SessionSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-sessionselection-where"},{"apiScope":"exported","doc":{"body":"\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Captured graph with explicit completeness"},"id":"LibTmux::Snapshot","kind":"class","modifiers":[],"name":"Snapshot","package":"LibTmux","product":"core","publicId":"LibTmux::Snapshot","qualifiedName":"LibTmux::Snapshot","signatures":[{"params":[],"raw":"package LibTmux::Snapshot;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::ClientSelection <LibTmux::ClientSelection>` in captured order. A loaded empty client set is valid."},"id":"LibTmux::Snapshot::clients","kind":"method","modifiers":[],"name":"clients","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::clients","qualifiedName":"LibTmux::Snapshot::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub clients($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":209,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-clients"},{"apiScope":"exported","doc":{"summary":"Return the capture completeness Boolean. The strict live acquisition path fails on incomplete topology; it does not synthesize empty relations."},"id":"LibTmux::Snapshot::complete","kind":"method","modifiers":[],"name":"complete","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::complete","qualifiedName":"LibTmux::Snapshot::complete","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub complete($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":104,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-complete"},{"apiScope":"exported","doc":{"summary":"`from_records(server_id => ..., generation => ..., sessions => [...], windows => [...], window_links => [...], panes => [...], clients => [...])` constructs a detached graph. Scalar records and relation IDs are copied. Omitted fields/collections remain unloaded; null is explicit. Invalid identities or inconsistent complete topology throw typed acquisition errors."},"id":"LibTmux::Snapshot::from_records","kind":"method","modifiers":[],"name":"from_records","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::from_records","qualifiedName":"LibTmux::Snapshot::from_records","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub from_records($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-from_records"},{"apiScope":"exported","doc":{"summary":"Return the captured daemon generation. :obj:`LibTmux::Server <LibTmux::Server>` checks it before mutations through captured handles; retained snapshots never silently refresh."},"id":"LibTmux::Snapshot::generation","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::generation","qualifiedName":"LibTmux::Snapshot::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":103,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-generation"},{"apiScope":"exported","doc":{"summary":"Return a fresh metadata hash with capture start/end, daemon version, and PID where acquired. Several commands observe an interval; the snapshot is not an atomic tmux transaction."},"id":"LibTmux::Snapshot::metadata","kind":"method","modifiers":[],"name":"metadata","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::metadata","qualifiedName":"LibTmux::Snapshot::metadata","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub metadata($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":105,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-metadata"},{"apiScope":"exported","doc":{"summary":"`pane_by_id('%3')` returns a :obj:`LibTmux::Pane <LibTmux::Pane>` or undef. The returned handle retains the captured graph after this wrapper goes out of scope."},"id":"LibTmux::Snapshot::pane_by_id","kind":"method","modifiers":[],"name":"pane_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::pane_by_id","qualifiedName":"LibTmux::Snapshot::pane_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"id"}],"raw":"sub pane_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":212,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-pane_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>` containing each physical pane identity once. Membership edits cannot change the graph store."},"id":"LibTmux::Snapshot::panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::panes","qualifiedName":"LibTmux::Snapshot::panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub panes($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":208,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-panes"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. Entity IDs are meaningful only within this scope and :obj:`\"generation\" <LibTmux::Snapshot::generation>`."},"id":"LibTmux::Snapshot::server_id","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::server_id","qualifiedName":"LibTmux::Snapshot::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":102,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-server_id"},{"apiScope":"exported","doc":{"summary":"`session_by_id('$1')` returns a :obj:`LibTmux::Session <LibTmux::Session>` or undef. Single quotes preserve the dollar-prefixed ID instead of interpolating a regex capture."},"id":"LibTmux::Snapshot::session_by_id","kind":"method","modifiers":[],"name":"session_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::session_by_id","qualifiedName":"LibTmux::Snapshot::session_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"id"}],"raw":"sub session_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":210,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-session_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::SessionSelection <LibTmux::SessionSelection>` in captured order. Empty loaded collections yield empty selections; unloaded collections throw."},"id":"LibTmux::Snapshot::sessions","kind":"method","modifiers":[],"name":"sessions","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::sessions","qualifiedName":"LibTmux::Snapshot::sessions","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub sessions($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":205,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-sessions"},{"apiScope":"exported","doc":{"summary":"Return independent scalar records and adjacency IDs for detached use. No handles or live transport are serialized."},"id":"LibTmux::Snapshot::to_records","kind":"method","modifiers":[],"name":"to_records","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::to_records","qualifiedName":"LibTmux::Snapshot::to_records","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub to_records($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":214,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-to_records"},{"apiScope":"exported","doc":{"summary":"`window_by_id('@3')` returns one physical :obj:`LibTmux::Window <LibTmux::Window>` or undef, independent of session link context."},"id":"LibTmux::Snapshot::window_by_id","kind":"method","modifiers":[],"name":"window_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::window_by_id","qualifiedName":"LibTmux::Snapshot::window_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"id"}],"raw":"sub window_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":211,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-window_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::WindowLinkSelection <LibTmux::WindowLinkSelection>` retaining every session/index association, including repeated links of one physical window."},"id":"LibTmux::Snapshot::window_links","kind":"method","modifiers":[],"name":"window_links","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::window_links","qualifiedName":"LibTmux::Snapshot::window_links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub window_links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":207,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-window_links"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::WindowSelection <LibTmux::WindowSelection>` containing each physical window identity once. Context lives in :obj:`\"window_links\" <LibTmux::Snapshot::window_links>`."},"id":"LibTmux::Snapshot::windows","kind":"method","modifiers":[],"name":"windows","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::windows","qualifiedName":"LibTmux::Snapshot::windows","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub windows($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Snapshot.pm","line":206,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-snapshot-windows"},{"apiScope":"exported","doc":{"body":"\n## RESULTS\n\n:obj:`LibTmux::CommandResult <LibTmux::CommandResult>` exposes stdout, stderr, exit_code, signal, raw_status, and success. Output remains octets.\n\nThe private supervisor owns program signals/groups and reaps the program. It receives CHLD, INT and TERM through a Linux signal descriptor, so child exit cannot wait for a deferred Perl handler. This mask belongs only to the supervisor; the command restores its inherited mask before execution. Application SIGCHLD handlers remain intact; SIGCHLD=IGNORE is refused. Cancellation handles are borrowed and remain open. Cancellation after release can have effects and never implies rollback. Parent death triggers cleanup.\n\nOwned supervisor and command branches close unrelated inherited descriptors through Linux `/proc/self/fd`, preserving the caller's handles. Native descriptors without close-on-exec cannot leak into a newly started tmux daemon. Only standard streams and each branch's required protocol/cancellation pipes remain open. Enumeration or closure failures prevent execution and throw :obj:`\"Transport\" in LibTmux::X <LibTmux::X::Transport>` or :obj:`\"Spawn\" in LibTmux::X <LibTmux::X::Spawn>`. No arbitrary descriptor-passing API is selected. Forking hosts with native threads remains unqualified.\n\n","summary":"Supervised literal process execution"},"id":"LibTmux::Transport","kind":"class","modifiers":[],"name":"Transport","package":"LibTmux","product":"core","publicId":"LibTmux::Transport","qualifiedName":"LibTmux::Transport","signatures":[{"params":[],"raw":"package LibTmux::Transport;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Transport.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-transport"},{"apiScope":"exported","doc":{"summary":"`run(argv => [...], stdin => $octets, timeout => $seconds, max_output => $bytes, cancel_fh => $handle)` returns a :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`. Stdout/stderr are separate octet strings. Nonzero exits are results; spawn, timeout, cancellation, output limits, and supervision failures throw :obj:`LibTmux::X <LibTmux::X>` exceptions. `timeout` bounds one command's execution loop, excluding supervisor setup, async queue waiting, and separate cleanup time."},"id":"LibTmux::Transport::run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::run","qualifiedName":"LibTmux::Transport::run","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub run($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Transport.pm","line":100,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-transport-run"},{"apiScope":"exported","doc":{"summary":"Return a :obj:`LibTmux::ProcessJob <LibTmux::ProcessJob>` for an executor adapter."},"id":"LibTmux::Transport::start","kind":"method","modifiers":[],"name":"start","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::start","qualifiedName":"LibTmux::Transport::start","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":23,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub start($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Transport.pm","line":96,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-transport-start"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured window entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Window","kind":"class","modifiers":[],"name":"Window","package":"LibTmux","product":"core","publicId":"LibTmux::Window","qualifiedName":"LibTmux::Window","signatures":[{"params":[],"raw":"package LibTmux::Window;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Pane <LibTmux::Pane>` entity or undef. Local captured data; no I/O."},"id":"LibTmux::Window::active_pane","kind":"method","modifiers":[],"name":"active_pane","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::active_pane","qualifiedName":"LibTmux::Window::active_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub active_pane($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-active_pane"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Window::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::generation","qualifiedName":"LibTmux::Window::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Window::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::height","qualifiedName":"LibTmux::Window::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::id","qualifiedName":"LibTmux::Window::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Window::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::identity","qualifiedName":"LibTmux::Window::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Window::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::kind","qualifiedName":"LibTmux::Window::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::layout","kind":"method","modifiers":[],"name":"layout","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::layout","qualifiedName":"LibTmux::Window::layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub layout($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-layout"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` entities. Local captured data; no I/O."},"id":"LibTmux::Window::links","kind":"method","modifiers":[],"name":"links","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::links","qualifiedName":"LibTmux::Window::links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-links"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::name","qualifiedName":"LibTmux::Window::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-name"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::Pane <LibTmux::Pane>` entities. Local captured data; no I/O."},"id":"LibTmux::Window::panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::panes","qualifiedName":"LibTmux::Window::panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub panes($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-panes"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Window::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::server_id","qualifiedName":"LibTmux::Window::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Window::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::to_record","qualifiedName":"LibTmux::Window::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-to_record"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Window::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::width","qualifiedName":"LibTmux::Window::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Window.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-window-width"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured window_link entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::WindowLink","kind":"class","modifiers":[],"name":"WindowLink","package":"LibTmux","product":"core","publicId":"LibTmux::WindowLink","qualifiedName":"LibTmux::WindowLink","signatures":[{"params":[],"raw":"package LibTmux::WindowLink;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::WindowLink::active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::active","qualifiedName":"LibTmux::WindowLink::active","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub active($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-active"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::WindowLink::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::generation","qualifiedName":"LibTmux::WindowLink::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-generation"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::WindowLink::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::id","qualifiedName":"LibTmux::WindowLink::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::WindowLink::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::identity","qualifiedName":"LibTmux::WindowLink::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-identity"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::WindowLink::index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::index","qualifiedName":"LibTmux::WindowLink::index","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub index($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-index"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::WindowLink::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::kind","qualifiedName":"LibTmux::WindowLink::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-kind"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::WindowLink::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::server_id","qualifiedName":"LibTmux::WindowLink::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-server_id"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Session <LibTmux::Session>` entity. Local captured data; no I/O."},"id":"LibTmux::WindowLink::session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::session","qualifiedName":"LibTmux::WindowLink::session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub session($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-session"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::WindowLink::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::to_record","qualifiedName":"LibTmux::WindowLink::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-to_record"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Window <LibTmux::Window>` entity. Local captured data; no I/O."},"id":"LibTmux::WindowLink::window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::window","qualifiedName":"LibTmux::WindowLink::window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub window($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLink.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlink-window"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` handles from one server generation. Empty instances still validate against the window_link schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured window_link entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::WindowLinkSelection","kind":"class","modifiers":[],"name":"WindowLinkSelection","package":"LibTmux","product":"core","publicId":"LibTmux::WindowLinkSelection","qualifiedName":"LibTmux::WindowLinkSelection","signatures":[{"params":[],"raw":"package LibTmux::WindowLinkSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowLinkSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::WindowLinkSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::count","qualifiedName":"LibTmux::WindowLinkSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::WindowLinkSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::exists","qualifiedName":"LibTmux::WindowLinkSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::WindowLinkSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::first","qualifiedName":"LibTmux::WindowLinkSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::WindowLinkSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::grep","qualifiedName":"LibTmux::WindowLinkSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::WindowLinkSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::iterator","qualifiedName":"LibTmux::WindowLinkSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::WindowLinkSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::new","qualifiedName":"LibTmux::WindowLinkSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::WindowLinkSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::one","qualifiedName":"LibTmux::WindowLinkSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::WindowLinkSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::one_or_undef","qualifiedName":"LibTmux::WindowLinkSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::WindowLinkSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::to_array","qualifiedName":"LibTmux::WindowLinkSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::WindowLinkSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::where","qualifiedName":"LibTmux::WindowLinkSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowlinkselection-where"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Window <LibTmux::Window>` handles from one server generation. Empty instances still validate against the window schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured window entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::WindowSelection","kind":"class","modifiers":[],"name":"WindowSelection","package":"LibTmux","product":"core","publicId":"LibTmux::WindowSelection","qualifiedName":"LibTmux::WindowSelection","signatures":[{"params":[],"raw":"package LibTmux::WindowSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/WindowSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::WindowSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::count","qualifiedName":"LibTmux::WindowSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::WindowSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::exists","qualifiedName":"LibTmux::WindowSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::WindowSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::first","qualifiedName":"LibTmux::WindowSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::WindowSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::grep","qualifiedName":"LibTmux::WindowSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::WindowSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::iterator","qualifiedName":"LibTmux::WindowSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::WindowSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::new","qualifiedName":"LibTmux::WindowSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::WindowSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::one","qualifiedName":"LibTmux::WindowSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::WindowSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::one_or_undef","qualifiedName":"LibTmux::WindowSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::WindowSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::to_array","qualifiedName":"LibTmux::WindowSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::WindowSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::where","qualifiedName":"LibTmux::WindowSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-windowselection-where"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use LibTmux::Workspace;\n    my $workspace = LibTmux::Workspace->from_json($json_octets);\n    my $plan = $workspace->plan(existing => 'error');\n    my $report = $workspace->load(server => $server);\n```\n\n\n## COMMAND LINE\n\nThe packaged `libtmux-workspace` executable exposes `validate`, `plan`, and `load`. `--dry-run` selects planning without tmux I/O. See the installed executable's help for socket and repeat-application options.\n\n","summary":"Versioned JSON configuration and owned orchestration"},"id":"LibTmux::Workspace","kind":"class","modifiers":[],"name":"Workspace","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace","qualifiedName":"LibTmux::Workspace","signatures":[{"params":[],"raw":"package LibTmux::Workspace;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace"},{"apiScope":"exported","doc":{"body":"\n## EXCEPTIONS\n\n","summary":"Workspace configuration and partial-load failures"},"id":"LibTmux::Workspace::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X","qualifiedName":"LibTmux::Workspace::X","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x"},{"apiScope":"exported","doc":{"summary":"Invalid versioned configuration. `path` identifies the rejected input."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Config","kind":"exception","modifiers":[],"name":"Config","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Config","qualifiedName":"LibTmux::Workspace::X::Config","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Config;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Config::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::count","qualifiedName":"LibTmux::Workspace::X::Config::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Config::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::details","qualifiedName":"LibTmux::Workspace::X::Config::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Config::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::dispatched","qualifiedName":"LibTmux::Workspace::X::Config::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Config::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::entity","qualifiedName":"LibTmux::Workspace::X::Config::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Config::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::expected","qualifiedName":"LibTmux::Workspace::X::Config::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Config::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::matched_ids","qualifiedName":"LibTmux::Workspace::X::Config::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Config::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::message","qualifiedName":"LibTmux::Workspace::X::Config::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Config::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::new","qualifiedName":"LibTmux::Workspace::X::Config::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Config::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::path","qualifiedName":"LibTmux::Workspace::X::Config::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Config::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::received","qualifiedName":"LibTmux::Workspace::X::Config::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Config::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::result","qualifiedName":"LibTmux::Workspace::X::Config::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Config::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::throw","qualifiedName":"LibTmux::Workspace::X::Config::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-config-throw"},{"apiScope":"exported","doc":{"summary":"An existing session conflicts with the selected repeat-application policy. No session is created until all names pass the conflict check."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Conflict","kind":"exception","modifiers":[],"name":"Conflict","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict","qualifiedName":"LibTmux::Workspace::X::Conflict","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Conflict;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":37,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Conflict::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::count","qualifiedName":"LibTmux::Workspace::X::Conflict::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Conflict::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::details","qualifiedName":"LibTmux::Workspace::X::Conflict::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Conflict::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::dispatched","qualifiedName":"LibTmux::Workspace::X::Conflict::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Conflict::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::entity","qualifiedName":"LibTmux::Workspace::X::Conflict::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Conflict::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::expected","qualifiedName":"LibTmux::Workspace::X::Conflict::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Conflict::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::matched_ids","qualifiedName":"LibTmux::Workspace::X::Conflict::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Conflict::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::message","qualifiedName":"LibTmux::Workspace::X::Conflict::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Conflict::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::new","qualifiedName":"LibTmux::Workspace::X::Conflict::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Conflict::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::path","qualifiedName":"LibTmux::Workspace::X::Conflict::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Conflict::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::received","qualifiedName":"LibTmux::Workspace::X::Conflict::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Conflict::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::result","qualifiedName":"LibTmux::Workspace::X::Conflict::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Conflict::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::throw","qualifiedName":"LibTmux::Workspace::X::Conflict::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-conflict-throw"},{"apiScope":"exported","doc":{"summary":"`cause` retains the original exception. `report` records completed steps, the failed step, dispatch uncertainty, and typed cleanup outcomes. Rollback affects only sessions whose creation was proven by returned core handles. See :obj:`\"load\" in LibTmux::Workspace <LibTmux::Workspace::load>` and :obj:`LibTmux::X <LibTmux::X>`."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Load","kind":"exception","modifiers":[],"name":"Load","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Load","qualifiedName":"LibTmux::Workspace::X::Load","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Load;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load"},{"apiScope":"exported","doc":{"summary":"For Load exceptions, return the original core or orchestration failure object."},"id":"LibTmux::Workspace::X::Load::cause","kind":"method","modifiers":[],"name":"cause","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::cause","qualifiedName":"LibTmux::Workspace::X::Load::cause","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub cause($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":42,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-cause"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Load::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::count","qualifiedName":"LibTmux::Workspace::X::Load::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Load::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::details","qualifiedName":"LibTmux::Workspace::X::Load::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Load::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::dispatched","qualifiedName":"LibTmux::Workspace::X::Load::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Load::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::entity","qualifiedName":"LibTmux::Workspace::X::Load::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Load::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::expected","qualifiedName":"LibTmux::Workspace::X::Load::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Load::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::matched_ids","qualifiedName":"LibTmux::Workspace::X::Load::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Load::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::message","qualifiedName":"LibTmux::Workspace::X::Load::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Load::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::new","qualifiedName":"LibTmux::Workspace::X::Load::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Load::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::path","qualifiedName":"LibTmux::Workspace::X::Load::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Load::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::received","qualifiedName":"LibTmux::Workspace::X::Load::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-received"},{"apiScope":"exported","doc":{"summary":"For Load exceptions, return the partial-load report. It contains created IDs, completed and failed steps, dispatch uncertainty, and cleanup failures. Each `cleanup_errors` entry contains `target` (the captured :obj:`identity <LibTmux::Entity::identity>`), `action` (`kill_session`), and `error` (the original exception). Entries follow rollback attempt order, reversing creation order. An empty array means no cleanup failure was observed. The primary :obj:`\"cause\" <LibTmux::Workspace::X::Load::cause>` and secondary exception objects retain their identity. Inspect their :obj:`dispatched <LibTmux::X::dispatched>` and :obj:`result <LibTmux::X::result>` fields without parsing prose. No I/O occurs."},"id":"LibTmux::Workspace::X::Load::report","kind":"method","modifiers":[],"name":"report","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::report","qualifiedName":"LibTmux::Workspace::X::Load::report","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub report($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":41,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-report"},{"apiScope":"exported","doc":{"body":"```perl\n    use JSON::PP ();\n    my $data = $error->report_data;\n    say JSON::PP->new->canonical->encode($data);\n```\n\nThe packaged `libtmux-workspace` CLI uses this export. Use :obj:`\"report\" <LibTmux::Workspace::X::Load::report>` when recovery needs the original typed exceptions rather than diagnostic data.","summary":"For Load exceptions, return a detached, JSON-safe report hashref. The primary cause and each cleanup error become records with `class`, `message`, known `path`, and `dispatched` (null means unknown). Core creation/load causes retain their cause chain; a repeated exception is marked `cycle`. Process results retain exit code, signal, raw wait status, and bounded stdout and stderr as `stdout_base64` and `stderr_base64` using [MIME::Base64](https://metacpan.org/pod/MIME::Base64). This diagnostic encoding does not serialize entity graphs or arbitrary exception internals. Other exceptions retain their class and string message. No I/O occurs; editing the export cannot change :obj:`\"report\" <LibTmux::Workspace::X::Load::report>` or :obj:`\"cause\" <LibTmux::Workspace::X::Load::cause>`."},"id":"LibTmux::Workspace::X::Load::report_data","kind":"method","modifiers":[],"name":"report_data","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::report_data","qualifiedName":"LibTmux::Workspace::X::Load::report_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub report_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":44,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-report_data"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Load::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::result","qualifiedName":"LibTmux::Workspace::X::Load::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Load::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::throw","qualifiedName":"LibTmux::Workspace::X::Load::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-x-load-throw"},{"apiScope":"exported","doc":{"summary":"Decode bounded UTF-8 JSON octets with core [JSON::PP](https://perldoc.perl.org/5.44.0/JSON::PP) and call :obj:`\"new\" <LibTmux::Workspace::new>`. Reject unsupported versions, unknown keys, invalid commands, and duplicate names. YAML is not part of this distribution."},"id":"LibTmux::Workspace::from_json","kind":"method","modifiers":[],"name":"from_json","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::from_json","qualifiedName":"LibTmux::Workspace::from_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"json"}],"raw":"sub from_json($class, $json)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":146,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-from_json"},{"apiScope":"exported","doc":{"body":"Return one report containing created IDs, skipped names, and completed steps. On failure, rollback only sessions returned by successful creation, then throw :obj:`Load <LibTmux::Workspace::X::Load>` with original cause and partial-effect report. An uncertain creation without a returned ID cannot be rolled back safely. Existing resources are never rollback targets. Layouts apply after splitting; working directories and environments reach every initial process. Completion means command acceptance and captured state, not application readiness.","summary":"`load(server => $server, existing => 'error'|'skip')` uses public :obj:`LibTmux::Server <LibTmux::Server>` operations. It checks all session-name conflicts before creation. `error` rejects any existing target with :obj:`Conflict <LibTmux::Workspace::X::Conflict>`; `skip` leaves that entire session alone, so repeated application creates only absent sessions. A missing server permits explicit creation; other acquisition failures propagate.","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Workspace;\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $workspace = LibTmux::Workspace->new(\n            config => {\n                schema   => 'libtmux.workspace/v1',\n                sessions => [\n                    {\n                        name    => 'workspace-example',\n                        windows => [\n                            {\n                                name   => 'api',\n                                cwd    => $root,\n                                layout => 'even-horizontal',\n                                panes  => [\n                                    {command => ['/bin/sleep', '120']},\n                                    {\n                                        command    => ['/bin/sleep', '120'],\n                                        horizontal => true\n                                    },\n                                ],\n                            }\n                        ],\n                    }\n                ],\n            }\n        );\n        die 'plan mutated state' if $workspace->plan->{mutates};\n        my $loaded = $workspace->load(server => $server);\n        die 'load failed'   unless $loaded->{status} eq 'loaded';\n        die 'panes missing' unless $server->snapshot->panes->count == 2;\n        die 'repeat did not skip'\n            unless $workspace->load(server => $server, existing => 'skip')\n            ->{skipped}->@* == 1;\n        say 'workspace load and repeat: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/d9fa7c5278d243c671a29cdb00e3a911ac651bfa/examples/workspace.pl"}]},"id":"LibTmux::Workspace::load","kind":"method","modifiers":[],"name":"load","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::load","qualifiedName":"LibTmux::Workspace::load","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub load($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":179,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-load"},{"apiScope":"exported","doc":{"summary":"`new(config => $hashref)` validates and copies a `libtmux.workspace/v1` configuration. No I/O occurs. Sessions contain named windows with nonempty pane arrays. Each pane requires literal `command` arguments or an explicit `shell_command`. Environment values inherit from workspace, session, and window, with pane values taking precedence. All configuration errors throw :obj:`Config <LibTmux::Workspace::X::Config>`."},"id":"LibTmux::Workspace::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::new","qualifiedName":"LibTmux::Workspace::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":47,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-new"},{"apiScope":"exported","doc":{"summary":"`plan(existing => 'error'|'skip')` returns a fresh data plan in input order. It performs no tmux I/O or mutations. A dry-run does not prove live availability or command success. Exports share no mutable arrays with the loader. No context-dependent return values are used."},"id":"LibTmux::Workspace::plan","kind":"method","modifiers":[],"name":"plan","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::plan","qualifiedName":"LibTmux::Workspace::plan","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub plan($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":165,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-workspace-plan"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nErrors stringify with class, path, and message. :obj:`\"Creation\" <LibTmux::X::Creation>` retains its original acquisition exception separately through `cause`. `details` returns diagnostic fields. Acquisition failures never represent an empty selection.\n\n\n## CARDINALITY AND DATA FAILURES\n\n\n## DIAGNOSTICS\n\n`message`, `path`, `entity`, `expected`, `received`, `matched_ids`, `count`, `result`, `dispatched`, and `details` expose applicable fields. See :obj:`\"one\" in LibTmux::Selection <LibTmux::Selection::one>`, :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`, and :obj:`LibTmux::Server <LibTmux::Server>` for failure boundaries.\n\n","summary":"Typed failures with readable diagnostics"},"id":"LibTmux::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux","product":"core","publicId":"LibTmux::X","qualifiedName":"LibTmux::X","signatures":[{"params":[],"raw":"package LibTmux::X;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x"},{"apiScope":"exported","doc":{"summary":"Observed generations or topology changed during capture."},"extends":["LibTmux::X"],"id":"LibTmux::X::AcquisitionRace","kind":"exception","modifiers":[],"name":"AcquisitionRace","package":"LibTmux","product":"core","publicId":"LibTmux::X::AcquisitionRace","qualifiedName":"LibTmux::X::AcquisitionRace","signatures":[{"params":[],"raw":"package LibTmux::X::AcquisitionRace;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":55,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::AcquisitionRace::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::count","qualifiedName":"LibTmux::X::AcquisitionRace::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::AcquisitionRace::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::details","qualifiedName":"LibTmux::X::AcquisitionRace::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::AcquisitionRace::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::dispatched","qualifiedName":"LibTmux::X::AcquisitionRace::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::AcquisitionRace::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::entity","qualifiedName":"LibTmux::X::AcquisitionRace::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::AcquisitionRace::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::expected","qualifiedName":"LibTmux::X::AcquisitionRace::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::AcquisitionRace::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::matched_ids","qualifiedName":"LibTmux::X::AcquisitionRace::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::AcquisitionRace::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::message","qualifiedName":"LibTmux::X::AcquisitionRace::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::AcquisitionRace::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::new","qualifiedName":"LibTmux::X::AcquisitionRace::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::AcquisitionRace::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::path","qualifiedName":"LibTmux::X::AcquisitionRace::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::AcquisitionRace::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::received","qualifiedName":"LibTmux::X::AcquisitionRace::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::AcquisitionRace::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::result","qualifiedName":"LibTmux::X::AcquisitionRace::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::AcquisitionRace::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::throw","qualifiedName":"LibTmux::X::AcquisitionRace::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-acquisitionrace-throw"},{"apiScope":"exported","doc":{"summary":"Execution was cancelled; cancellation does not roll back effects."},"extends":["LibTmux::X"],"id":"LibTmux::X::Cancelled","kind":"exception","modifiers":[],"name":"Cancelled","package":"LibTmux","product":"core","publicId":"LibTmux::X::Cancelled","qualifiedName":"LibTmux::X::Cancelled","signatures":[{"params":[],"raw":"package LibTmux::X::Cancelled;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":41,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Cancelled::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::count","qualifiedName":"LibTmux::X::Cancelled::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Cancelled::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::details","qualifiedName":"LibTmux::X::Cancelled::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Cancelled::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::dispatched","qualifiedName":"LibTmux::X::Cancelled::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Cancelled::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::entity","qualifiedName":"LibTmux::X::Cancelled::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Cancelled::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::expected","qualifiedName":"LibTmux::X::Cancelled::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Cancelled::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::matched_ids","qualifiedName":"LibTmux::X::Cancelled::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Cancelled::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::message","qualifiedName":"LibTmux::X::Cancelled::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Cancelled::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::new","qualifiedName":"LibTmux::X::Cancelled::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Cancelled::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::path","qualifiedName":"LibTmux::X::Cancelled::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Cancelled::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::received","qualifiedName":"LibTmux::X::Cancelled::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Cancelled::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::result","qualifiedName":"LibTmux::X::Cancelled::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Cancelled::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::throw","qualifiedName":"LibTmux::X::Cancelled::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-cancelled-throw"},{"apiScope":"exported","doc":{"summary":"A tmux record or field could not be decoded."},"extends":["LibTmux::X"],"id":"LibTmux::X::Codec","kind":"exception","modifiers":[],"name":"Codec","package":"LibTmux","product":"core","publicId":"LibTmux::X::Codec","qualifiedName":"LibTmux::X::Codec","signatures":[{"params":[],"raw":"package LibTmux::X::Codec;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":47,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Codec::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::count","qualifiedName":"LibTmux::X::Codec::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Codec::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::details","qualifiedName":"LibTmux::X::Codec::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Codec::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::dispatched","qualifiedName":"LibTmux::X::Codec::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Codec::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::entity","qualifiedName":"LibTmux::X::Codec::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Codec::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::expected","qualifiedName":"LibTmux::X::Codec::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Codec::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::matched_ids","qualifiedName":"LibTmux::X::Codec::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Codec::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::message","qualifiedName":"LibTmux::X::Codec::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Codec::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::new","qualifiedName":"LibTmux::X::Codec::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Codec::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::path","qualifiedName":"LibTmux::X::Codec::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Codec::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::received","qualifiedName":"LibTmux::X::Codec::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Codec::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::result","qualifiedName":"LibTmux::X::Codec::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Codec::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::throw","qualifiedName":"LibTmux::X::Codec::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-codec-throw"},{"apiScope":"exported","doc":{"summary":"tmux reported nonzero status; result retains stdout/stderr/status."},"extends":["LibTmux::X"],"id":"LibTmux::X::Command","kind":"exception","modifiers":[],"name":"Command","package":"LibTmux","product":"core","publicId":"LibTmux::X::Command","qualifiedName":"LibTmux::X::Command","signatures":[{"params":[],"raw":"package LibTmux::X::Command;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":49,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Command::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::count","qualifiedName":"LibTmux::X::Command::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Command::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::details","qualifiedName":"LibTmux::X::Command::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Command::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::dispatched","qualifiedName":"LibTmux::X::Command::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Command::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::entity","qualifiedName":"LibTmux::X::Command::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Command::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::expected","qualifiedName":"LibTmux::X::Command::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Command::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::matched_ids","qualifiedName":"LibTmux::X::Command::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Command::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::message","qualifiedName":"LibTmux::X::Command::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Command::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::new","qualifiedName":"LibTmux::X::Command::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Command::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::path","qualifiedName":"LibTmux::X::Command::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Command::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::received","qualifiedName":"LibTmux::X::Command::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Command::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::result","qualifiedName":"LibTmux::X::Command::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Command::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::throw","qualifiedName":"LibTmux::X::Command::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-command-throw"},{"apiScope":"exported","doc":{"summary":"A creation command succeeded but subsequent receipt decoding or capture failed. `created` returns a minimal generation-scoped entity handle when the command's receipt was decoded; other fields remain unloaded. `cause` preserves the original acquisition failure. `dispatched` is true. The returned handle permits explicit, generation-checked cleanup; absent receipts leave effects uncertain. See :obj:`\"new_session\" in LibTmux::Server <LibTmux::Server::new_session>`."},"extends":["LibTmux::X"],"id":"LibTmux::X::Creation","kind":"exception","modifiers":[],"name":"Creation","package":"LibTmux","product":"core","publicId":"LibTmux::X::Creation","qualifiedName":"LibTmux::X::Creation","signatures":[{"params":[],"raw":"package LibTmux::X::Creation;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":59,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation"},{"apiScope":"exported","doc":{"summary":"Return the original acquisition exception for :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>`."},"id":"LibTmux::X::Creation::cause","kind":"method","modifiers":[],"name":"cause","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::cause","qualifiedName":"LibTmux::X::Creation::cause","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub cause($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":62,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-cause"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Creation::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::count","qualifiedName":"LibTmux::X::Creation::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-count"},{"apiScope":"exported","doc":{"summary":"Creation failures expose a minimal generation-scoped entity receipt, or undef. Only :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` provides this method."},"id":"LibTmux::X::Creation::created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::created","qualifiedName":"LibTmux::X::Creation::created","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub created($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":61,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-created"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Creation::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::details","qualifiedName":"LibTmux::X::Creation::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Creation::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::dispatched","qualifiedName":"LibTmux::X::Creation::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Creation::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::entity","qualifiedName":"LibTmux::X::Creation::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Creation::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::expected","qualifiedName":"LibTmux::X::Creation::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Creation::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::matched_ids","qualifiedName":"LibTmux::X::Creation::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Creation::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::message","qualifiedName":"LibTmux::X::Creation::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Creation::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::new","qualifiedName":"LibTmux::X::Creation::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Creation::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::path","qualifiedName":"LibTmux::X::Creation::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Creation::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::received","qualifiedName":"LibTmux::X::Creation::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Creation::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::result","qualifiedName":"LibTmux::X::Creation::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Creation::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::throw","qualifiedName":"LibTmux::X::Creation::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-creation-throw"},{"apiScope":"exported","doc":{"summary":"Invalid operation or transport argument before dispatch."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidArgument","kind":"exception","modifiers":[],"name":"InvalidArgument","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidArgument","qualifiedName":"LibTmux::X::InvalidArgument","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidArgument;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidArgument::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::count","qualifiedName":"LibTmux::X::InvalidArgument::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidArgument::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::details","qualifiedName":"LibTmux::X::InvalidArgument::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidArgument::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::dispatched","qualifiedName":"LibTmux::X::InvalidArgument::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidArgument::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::entity","qualifiedName":"LibTmux::X::InvalidArgument::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidArgument::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::expected","qualifiedName":"LibTmux::X::InvalidArgument::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidArgument::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::matched_ids","qualifiedName":"LibTmux::X::InvalidArgument::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidArgument::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::message","qualifiedName":"LibTmux::X::InvalidArgument::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidArgument::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::new","qualifiedName":"LibTmux::X::InvalidArgument::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidArgument::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::path","qualifiedName":"LibTmux::X::InvalidArgument::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidArgument::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::received","qualifiedName":"LibTmux::X::InvalidArgument::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidArgument::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::result","qualifiedName":"LibTmux::X::InvalidArgument::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidArgument::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::throw","qualifiedName":"LibTmux::X::InvalidArgument::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidargument-throw"},{"apiScope":"exported","doc":{"summary":"Invalid criteria data; path, expected, and received describe the boundary."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidFilter","kind":"exception","modifiers":[],"name":"InvalidFilter","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidFilter","qualifiedName":"LibTmux::X::InvalidFilter","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidFilter;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidFilter::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::count","qualifiedName":"LibTmux::X::InvalidFilter::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidFilter::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::details","qualifiedName":"LibTmux::X::InvalidFilter::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidFilter::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::dispatched","qualifiedName":"LibTmux::X::InvalidFilter::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidFilter::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::entity","qualifiedName":"LibTmux::X::InvalidFilter::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidFilter::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::expected","qualifiedName":"LibTmux::X::InvalidFilter::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidFilter::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::matched_ids","qualifiedName":"LibTmux::X::InvalidFilter::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidFilter::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::message","qualifiedName":"LibTmux::X::InvalidFilter::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidFilter::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::new","qualifiedName":"LibTmux::X::InvalidFilter::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidFilter::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::path","qualifiedName":"LibTmux::X::InvalidFilter::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidFilter::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::received","qualifiedName":"LibTmux::X::InvalidFilter::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidFilter::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::result","qualifiedName":"LibTmux::X::InvalidFilter::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidFilter::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::throw","qualifiedName":"LibTmux::X::InvalidFilter::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidfilter-throw"},{"apiScope":"exported","doc":{"summary":"Undefined, hole, wrong-kind, or incompatible-generation membership."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidSelection","kind":"exception","modifiers":[],"name":"InvalidSelection","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidSelection","qualifiedName":"LibTmux::X::InvalidSelection","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidSelection;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":23,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidSelection::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::count","qualifiedName":"LibTmux::X::InvalidSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidSelection::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::details","qualifiedName":"LibTmux::X::InvalidSelection::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidSelection::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::dispatched","qualifiedName":"LibTmux::X::InvalidSelection::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidSelection::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::entity","qualifiedName":"LibTmux::X::InvalidSelection::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidSelection::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::expected","qualifiedName":"LibTmux::X::InvalidSelection::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidSelection::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::matched_ids","qualifiedName":"LibTmux::X::InvalidSelection::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidSelection::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::message","qualifiedName":"LibTmux::X::InvalidSelection::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidSelection::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::new","qualifiedName":"LibTmux::X::InvalidSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidSelection::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::path","qualifiedName":"LibTmux::X::InvalidSelection::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidSelection::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::received","qualifiedName":"LibTmux::X::InvalidSelection::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidSelection::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::result","qualifiedName":"LibTmux::X::InvalidSelection::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidSelection::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::throw","qualifiedName":"LibTmux::X::InvalidSelection::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-invalidselection-throw"},{"apiScope":"exported","doc":{"summary":"At least two occurrences matched. matched_ids preserves occurrence diagnostics."},"extends":["LibTmux::X"],"id":"LibTmux::X::MultipleMatches","kind":"exception","modifiers":[],"name":"MultipleMatches","package":"LibTmux","product":"core","publicId":"LibTmux::X::MultipleMatches","qualifiedName":"LibTmux::X::MultipleMatches","signatures":[{"params":[],"raw":"package LibTmux::X::MultipleMatches;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":29,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::MultipleMatches::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::count","qualifiedName":"LibTmux::X::MultipleMatches::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::MultipleMatches::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::details","qualifiedName":"LibTmux::X::MultipleMatches::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::MultipleMatches::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::dispatched","qualifiedName":"LibTmux::X::MultipleMatches::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::MultipleMatches::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::entity","qualifiedName":"LibTmux::X::MultipleMatches::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::MultipleMatches::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::expected","qualifiedName":"LibTmux::X::MultipleMatches::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::MultipleMatches::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::matched_ids","qualifiedName":"LibTmux::X::MultipleMatches::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::MultipleMatches::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::message","qualifiedName":"LibTmux::X::MultipleMatches::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::MultipleMatches::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::new","qualifiedName":"LibTmux::X::MultipleMatches::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::MultipleMatches::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::path","qualifiedName":"LibTmux::X::MultipleMatches::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::MultipleMatches::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::received","qualifiedName":"LibTmux::X::MultipleMatches::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::MultipleMatches::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::result","qualifiedName":"LibTmux::X::MultipleMatches::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::MultipleMatches::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::throw","qualifiedName":"LibTmux::X::MultipleMatches::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-multiplematches-throw"},{"apiScope":"exported","doc":{"summary":"No occurrence matched one()."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoMatch","kind":"exception","modifiers":[],"name":"NoMatch","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoMatch","qualifiedName":"LibTmux::X::NoMatch","signatures":[{"params":[],"raw":"package LibTmux::X::NoMatch;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":27,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoMatch::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::count","qualifiedName":"LibTmux::X::NoMatch::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoMatch::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::details","qualifiedName":"LibTmux::X::NoMatch::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoMatch::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::dispatched","qualifiedName":"LibTmux::X::NoMatch::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoMatch::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::entity","qualifiedName":"LibTmux::X::NoMatch::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoMatch::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::expected","qualifiedName":"LibTmux::X::NoMatch::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoMatch::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::matched_ids","qualifiedName":"LibTmux::X::NoMatch::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoMatch::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::message","qualifiedName":"LibTmux::X::NoMatch::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoMatch::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::new","qualifiedName":"LibTmux::X::NoMatch::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoMatch::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::path","qualifiedName":"LibTmux::X::NoMatch::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoMatch::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::received","qualifiedName":"LibTmux::X::NoMatch::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoMatch::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::result","qualifiedName":"LibTmux::X::NoMatch::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoMatch::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::throw","qualifiedName":"LibTmux::X::NoMatch::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nomatch-throw"},{"apiScope":"exported","doc":{"summary":"The selected server cannot be reached."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoServer","kind":"exception","modifiers":[],"name":"NoServer","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoServer","qualifiedName":"LibTmux::X::NoServer","signatures":[{"params":[],"raw":"package LibTmux::X::NoServer;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":51,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoServer::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::count","qualifiedName":"LibTmux::X::NoServer::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoServer::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::details","qualifiedName":"LibTmux::X::NoServer::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoServer::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::dispatched","qualifiedName":"LibTmux::X::NoServer::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoServer::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::entity","qualifiedName":"LibTmux::X::NoServer::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoServer::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::expected","qualifiedName":"LibTmux::X::NoServer::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoServer::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::matched_ids","qualifiedName":"LibTmux::X::NoServer::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoServer::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::message","qualifiedName":"LibTmux::X::NoServer::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoServer::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::new","qualifiedName":"LibTmux::X::NoServer::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoServer::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::path","qualifiedName":"LibTmux::X::NoServer::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoServer::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::received","qualifiedName":"LibTmux::X::NoServer::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoServer::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::result","qualifiedName":"LibTmux::X::NoServer::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoServer::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::throw","qualifiedName":"LibTmux::X::NoServer::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-noserver-throw"},{"apiScope":"exported","doc":{"summary":"The selected stable target no longer exists. Native result diagnostics are retained. This differs from a stale generation and from an arbitrary command failure; acquire a new snapshot before choosing recovery."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoSuchTarget","kind":"exception","modifiers":[],"name":"NoSuchTarget","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoSuchTarget","qualifiedName":"LibTmux::X::NoSuchTarget","signatures":[{"params":[],"raw":"package LibTmux::X::NoSuchTarget;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":65,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoSuchTarget::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::count","qualifiedName":"LibTmux::X::NoSuchTarget::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoSuchTarget::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::details","qualifiedName":"LibTmux::X::NoSuchTarget::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoSuchTarget::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::dispatched","qualifiedName":"LibTmux::X::NoSuchTarget::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoSuchTarget::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::entity","qualifiedName":"LibTmux::X::NoSuchTarget::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoSuchTarget::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::expected","qualifiedName":"LibTmux::X::NoSuchTarget::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoSuchTarget::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::matched_ids","qualifiedName":"LibTmux::X::NoSuchTarget::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoSuchTarget::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::message","qualifiedName":"LibTmux::X::NoSuchTarget::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoSuchTarget::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::new","qualifiedName":"LibTmux::X::NoSuchTarget::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoSuchTarget::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::path","qualifiedName":"LibTmux::X::NoSuchTarget::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoSuchTarget::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::received","qualifiedName":"LibTmux::X::NoSuchTarget::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoSuchTarget::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::result","qualifiedName":"LibTmux::X::NoSuchTarget::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoSuchTarget::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::throw","qualifiedName":"LibTmux::X::NoSuchTarget::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-nosuchtarget-throw"},{"apiScope":"exported","doc":{"summary":"Retained process output exceeded the configured bound."},"extends":["LibTmux::X"],"id":"LibTmux::X::OutputLimit","kind":"exception","modifiers":[],"name":"OutputLimit","package":"LibTmux","product":"core","publicId":"LibTmux::X::OutputLimit","qualifiedName":"LibTmux::X::OutputLimit","signatures":[{"params":[],"raw":"package LibTmux::X::OutputLimit;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":43,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::OutputLimit::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::count","qualifiedName":"LibTmux::X::OutputLimit::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::OutputLimit::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::details","qualifiedName":"LibTmux::X::OutputLimit::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::OutputLimit::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::dispatched","qualifiedName":"LibTmux::X::OutputLimit::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::OutputLimit::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::entity","qualifiedName":"LibTmux::X::OutputLimit::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::OutputLimit::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::expected","qualifiedName":"LibTmux::X::OutputLimit::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::OutputLimit::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::matched_ids","qualifiedName":"LibTmux::X::OutputLimit::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::OutputLimit::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::message","qualifiedName":"LibTmux::X::OutputLimit::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::OutputLimit::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::new","qualifiedName":"LibTmux::X::OutputLimit::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::OutputLimit::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::path","qualifiedName":"LibTmux::X::OutputLimit::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::OutputLimit::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::received","qualifiedName":"LibTmux::X::OutputLimit::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::OutputLimit::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::result","qualifiedName":"LibTmux::X::OutputLimit::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::OutputLimit::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::throw","qualifiedName":"LibTmux::X::OutputLimit::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-outputlimit-throw"},{"apiScope":"exported","doc":{"summary":"Native candidates disagree with captured local matches, or an expert native query returned an uncaptured ID. `details->{verification}` contains the detached :obj:`\"VERIFICATION REPORT\" in LibTmux::Server <LibTmux::Server#VERIFICATION%20REPORT>`. The cause may be concurrent change, a translation defect or backend semantics; the comparison does not identify it. :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` throws this for require or expert queries, while auto reports fallback through its optional observer."},"extends":["LibTmux::X"],"id":"LibTmux::X::QueryMismatch","kind":"exception","modifiers":[],"name":"QueryMismatch","package":"LibTmux","product":"core","publicId":"LibTmux::X::QueryMismatch","qualifiedName":"LibTmux::X::QueryMismatch","signatures":[{"params":[],"raw":"package LibTmux::X::QueryMismatch;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":57,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::QueryMismatch::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::count","qualifiedName":"LibTmux::X::QueryMismatch::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::QueryMismatch::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::details","qualifiedName":"LibTmux::X::QueryMismatch::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::QueryMismatch::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::dispatched","qualifiedName":"LibTmux::X::QueryMismatch::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::QueryMismatch::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::entity","qualifiedName":"LibTmux::X::QueryMismatch::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::QueryMismatch::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::expected","qualifiedName":"LibTmux::X::QueryMismatch::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::QueryMismatch::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::matched_ids","qualifiedName":"LibTmux::X::QueryMismatch::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::QueryMismatch::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::message","qualifiedName":"LibTmux::X::QueryMismatch::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::QueryMismatch::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::new","qualifiedName":"LibTmux::X::QueryMismatch::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::QueryMismatch::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::path","qualifiedName":"LibTmux::X::QueryMismatch::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::QueryMismatch::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::received","qualifiedName":"LibTmux::X::QueryMismatch::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::QueryMismatch::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::result","qualifiedName":"LibTmux::X::QueryMismatch::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::QueryMismatch::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::throw","qualifiedName":"LibTmux::X::QueryMismatch::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-querymismatch-throw"},{"apiScope":"exported","doc":{"summary":"The executable could not start; dispatch is distinguished from command failure."},"extends":["LibTmux::X"],"id":"LibTmux::X::Spawn","kind":"exception","modifiers":[],"name":"Spawn","package":"LibTmux","product":"core","publicId":"LibTmux::X::Spawn","qualifiedName":"LibTmux::X::Spawn","signatures":[{"params":[],"raw":"package LibTmux::X::Spawn;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":37,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Spawn::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::count","qualifiedName":"LibTmux::X::Spawn::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Spawn::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::details","qualifiedName":"LibTmux::X::Spawn::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Spawn::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::dispatched","qualifiedName":"LibTmux::X::Spawn::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Spawn::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::entity","qualifiedName":"LibTmux::X::Spawn::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Spawn::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::expected","qualifiedName":"LibTmux::X::Spawn::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Spawn::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::matched_ids","qualifiedName":"LibTmux::X::Spawn::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Spawn::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::message","qualifiedName":"LibTmux::X::Spawn::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Spawn::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::new","qualifiedName":"LibTmux::X::Spawn::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Spawn::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::path","qualifiedName":"LibTmux::X::Spawn::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Spawn::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::received","qualifiedName":"LibTmux::X::Spawn::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Spawn::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::result","qualifiedName":"LibTmux::X::Spawn::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Spawn::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::throw","qualifiedName":"LibTmux::X::Spawn::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-spawn-throw"},{"apiScope":"exported","doc":{"summary":"A captured generation or contextual target no longer identifies the same resource."},"extends":["LibTmux::X"],"id":"LibTmux::X::StaleReference","kind":"exception","modifiers":[],"name":"StaleReference","package":"LibTmux","product":"core","publicId":"LibTmux::X::StaleReference","qualifiedName":"LibTmux::X::StaleReference","signatures":[{"params":[],"raw":"package LibTmux::X::StaleReference;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":53,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::StaleReference::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::count","qualifiedName":"LibTmux::X::StaleReference::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::StaleReference::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::details","qualifiedName":"LibTmux::X::StaleReference::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::StaleReference::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::dispatched","qualifiedName":"LibTmux::X::StaleReference::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::StaleReference::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::entity","qualifiedName":"LibTmux::X::StaleReference::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::StaleReference::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::expected","qualifiedName":"LibTmux::X::StaleReference::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::StaleReference::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::matched_ids","qualifiedName":"LibTmux::X::StaleReference::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::StaleReference::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::message","qualifiedName":"LibTmux::X::StaleReference::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::StaleReference::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::new","qualifiedName":"LibTmux::X::StaleReference::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::StaleReference::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::path","qualifiedName":"LibTmux::X::StaleReference::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::StaleReference::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::received","qualifiedName":"LibTmux::X::StaleReference::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::StaleReference::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::result","qualifiedName":"LibTmux::X::StaleReference::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::StaleReference::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::throw","qualifiedName":"LibTmux::X::StaleReference::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-stalereference-throw"},{"apiScope":"exported","doc":{"summary":"Execution exceeded its deadline; effects may already have occurred."},"extends":["LibTmux::X"],"id":"LibTmux::X::Timeout","kind":"exception","modifiers":[],"name":"Timeout","package":"LibTmux","product":"core","publicId":"LibTmux::X::Timeout","qualifiedName":"LibTmux::X::Timeout","signatures":[{"params":[],"raw":"package LibTmux::X::Timeout;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Timeout::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::count","qualifiedName":"LibTmux::X::Timeout::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Timeout::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::details","qualifiedName":"LibTmux::X::Timeout::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Timeout::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::dispatched","qualifiedName":"LibTmux::X::Timeout::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Timeout::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::entity","qualifiedName":"LibTmux::X::Timeout::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Timeout::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::expected","qualifiedName":"LibTmux::X::Timeout::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Timeout::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::matched_ids","qualifiedName":"LibTmux::X::Timeout::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Timeout::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::message","qualifiedName":"LibTmux::X::Timeout::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Timeout::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::new","qualifiedName":"LibTmux::X::Timeout::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Timeout::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::path","qualifiedName":"LibTmux::X::Timeout::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Timeout::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::received","qualifiedName":"LibTmux::X::Timeout::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Timeout::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::result","qualifiedName":"LibTmux::X::Timeout::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Timeout::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::throw","qualifiedName":"LibTmux::X::Timeout::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-timeout-throw"},{"apiScope":"exported","doc":{"summary":"Process supervision or result framing failed."},"extends":["LibTmux::X"],"id":"LibTmux::X::Transport","kind":"exception","modifiers":[],"name":"Transport","package":"LibTmux","product":"core","publicId":"LibTmux::X::Transport","qualifiedName":"LibTmux::X::Transport","signatures":[{"params":[],"raw":"package LibTmux::X::Transport;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":45,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Transport::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::count","qualifiedName":"LibTmux::X::Transport::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Transport::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::details","qualifiedName":"LibTmux::X::Transport::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Transport::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::dispatched","qualifiedName":"LibTmux::X::Transport::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Transport::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::entity","qualifiedName":"LibTmux::X::Transport::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Transport::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::expected","qualifiedName":"LibTmux::X::Transport::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Transport::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::matched_ids","qualifiedName":"LibTmux::X::Transport::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Transport::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::message","qualifiedName":"LibTmux::X::Transport::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Transport::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::new","qualifiedName":"LibTmux::X::Transport::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Transport::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::path","qualifiedName":"LibTmux::X::Transport::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Transport::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::received","qualifiedName":"LibTmux::X::Transport::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Transport::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::result","qualifiedName":"LibTmux::X::Transport::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Transport::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::throw","qualifiedName":"LibTmux::X::Transport::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-transport-throw"},{"apiScope":"exported","doc":{"summary":"A required field or relation is not available in captured data."},"extends":["LibTmux::X"],"id":"LibTmux::X::Unloaded","kind":"exception","modifiers":[],"name":"Unloaded","package":"LibTmux","product":"core","publicId":"LibTmux::X::Unloaded","qualifiedName":"LibTmux::X::Unloaded","signatures":[{"params":[],"raw":"package LibTmux::X::Unloaded;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":31,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Unloaded::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::count","qualifiedName":"LibTmux::X::Unloaded::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Unloaded::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::details","qualifiedName":"LibTmux::X::Unloaded::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Unloaded::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::dispatched","qualifiedName":"LibTmux::X::Unloaded::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Unloaded::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::entity","qualifiedName":"LibTmux::X::Unloaded::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Unloaded::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::expected","qualifiedName":"LibTmux::X::Unloaded::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Unloaded::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::matched_ids","qualifiedName":"LibTmux::X::Unloaded::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Unloaded::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::message","qualifiedName":"LibTmux::X::Unloaded::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Unloaded::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::new","qualifiedName":"LibTmux::X::Unloaded::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Unloaded::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::path","qualifiedName":"LibTmux::X::Unloaded::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Unloaded::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::received","qualifiedName":"LibTmux::X::Unloaded::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Unloaded::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::result","qualifiedName":"LibTmux::X::Unloaded::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Unloaded::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::throw","qualifiedName":"LibTmux::X::Unloaded::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unloaded-throw"},{"apiScope":"exported","doc":{"summary":"A daemon or execution capability is unavailable."},"extends":["LibTmux::X"],"id":"LibTmux::X::Unsupported","kind":"exception","modifiers":[],"name":"Unsupported","package":"LibTmux","product":"core","publicId":"LibTmux::X::Unsupported","qualifiedName":"LibTmux::X::Unsupported","signatures":[{"params":[],"raw":"package LibTmux::X::Unsupported;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Unsupported::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::count","qualifiedName":"LibTmux::X::Unsupported::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Unsupported::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::details","qualifiedName":"LibTmux::X::Unsupported::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Unsupported::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::dispatched","qualifiedName":"LibTmux::X::Unsupported::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Unsupported::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::entity","qualifiedName":"LibTmux::X::Unsupported::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Unsupported::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::expected","qualifiedName":"LibTmux::X::Unsupported::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Unsupported::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::matched_ids","qualifiedName":"LibTmux::X::Unsupported::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Unsupported::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::message","qualifiedName":"LibTmux::X::Unsupported::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Unsupported::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::new","qualifiedName":"LibTmux::X::Unsupported::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Unsupported::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::path","qualifiedName":"LibTmux::X::Unsupported::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Unsupported::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::received","qualifiedName":"LibTmux::X::Unsupported::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Unsupported::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::result","qualifiedName":"LibTmux::X::Unsupported::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Unsupported::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::throw","qualifiedName":"LibTmux::X::Unsupported::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupported-throw"},{"apiScope":"exported","doc":{"summary":"A local value has no supported portable wire representation."},"extends":["LibTmux::X"],"id":"LibTmux::X::UnsupportedValue","kind":"exception","modifiers":[],"name":"UnsupportedValue","package":"LibTmux","product":"core","publicId":"LibTmux::X::UnsupportedValue","qualifiedName":"LibTmux::X::UnsupportedValue","signatures":[{"params":[],"raw":"package LibTmux::X::UnsupportedValue;"}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":33,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::UnsupportedValue::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::count","qualifiedName":"LibTmux::X::UnsupportedValue::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::UnsupportedValue::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::details","qualifiedName":"LibTmux::X::UnsupportedValue::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::UnsupportedValue::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::dispatched","qualifiedName":"LibTmux::X::UnsupportedValue::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::UnsupportedValue::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::entity","qualifiedName":"LibTmux::X::UnsupportedValue::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::UnsupportedValue::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::expected","qualifiedName":"LibTmux::X::UnsupportedValue::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::UnsupportedValue::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::matched_ids","qualifiedName":"LibTmux::X::UnsupportedValue::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::UnsupportedValue::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::message","qualifiedName":"LibTmux::X::UnsupportedValue::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::UnsupportedValue::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::new","qualifiedName":"LibTmux::X::UnsupportedValue::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::UnsupportedValue::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::path","qualifiedName":"LibTmux::X::UnsupportedValue::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::UnsupportedValue::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::received","qualifiedName":"LibTmux::X::UnsupportedValue::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::UnsupportedValue::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::result","qualifiedName":"LibTmux::X::UnsupportedValue::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::UnsupportedValue::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::throw","qualifiedName":"LibTmux::X::UnsupportedValue::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-unsupportedvalue-throw"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::count","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::count","qualifiedName":"LibTmux::X::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::details","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::details","qualifiedName":"LibTmux::X::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::dispatched","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::dispatched","qualifiedName":"LibTmux::X::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::entity","qualifiedName":"LibTmux::X::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::expected","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::expected","qualifiedName":"LibTmux::X::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::matched_ids","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::matched_ids","qualifiedName":"LibTmux::X::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::message","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::message","qualifiedName":"LibTmux::X::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::new","qualifiedName":"LibTmux::X::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::path","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::path","qualifiedName":"LibTmux::X::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::received","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::received","qualifiedName":"LibTmux::X::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::result","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::result","qualifiedName":"LibTmux::X::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::throw","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::throw","qualifiedName":"LibTmux::X::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa"},"slug":"libtmux-x-throw"}]}
+{"port":"perl","repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","sources":[{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","package":"LibTmux","product":"core","repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","version":"0.003"},{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","package":"LibTmux-Async","product":"core","repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","version":"0.003"},{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","package":"LibTmux-Workspace","product":"workspace","repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","version":"0.003"}],"extractor":"Perl PPI 1.291 + Pod::Simple native POD v1","nativeProvenance":{"exporter":{"file":"scripts/export-api.pl","perl":"v5.44.0","ppi":"1.291","repository":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","sha256":"650c06a72047602f3108ae5720d21752dffa03d9aeebd8adf4a851d40ba81321","working_tree":false},"files":[{"path":"packages/core/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/core/Makefile.PL","sha256":"dfe94f878c5940a67e8df65811a39b093ba42b9516d4a57dad3dc898b05cd523"},{"path":"packages/core/README.md","sha256":"70e80768bc35239291616ff7a1f027326346f742f360168611c59f6c4da22b78"},{"path":"packages/core/cpanfile","sha256":"c3872a5a5b6b7f367534376cd4db51f7ebf4a1ee31a4560c0de2661c9b25bdf7"},{"path":"packages/core/lib/LibTmux.pm","sha256":"da7690215acae3f9a4f2d5aeb6ef1785d2b5f0f84718fd130bca4666c8e908c9"},{"path":"packages/core/lib/LibTmux/Client.pm","sha256":"1d6a7fe38802d134215f476727e014cceb7f189d608a45e907aa74a9b33377a3"},{"path":"packages/core/lib/LibTmux/ClientSelection.pm","sha256":"24c200afefcb28a5df984b99db8df4253986176b005daf175ecd3f45ebc50aab"},{"path":"packages/core/lib/LibTmux/Codec.pm","sha256":"c3517cd3542e7622b575ddf3a8274841e43df843d4b9b4739d79268ed047a327"},{"path":"packages/core/lib/LibTmux/CommandResult.pm","sha256":"c05fee72a809d924d96908eeb5c9d4c328b088d5e4f9692f292f9c96b13fdbd9"},{"path":"packages/core/lib/LibTmux/Entity.pm","sha256":"46fbe507850d5880f59d78a732270e2554d5e4fe112d8a8013e60a9fca0d5c20"},{"path":"packages/core/lib/LibTmux/Filter.pm","sha256":"fa3b65a22515a6086d06f044e06eeb454575b926e41216419f445d084c8cd8bc"},{"path":"packages/core/lib/LibTmux/Operation.pm","sha256":"dc63406ae06d858fad89347a146cb7ba8496e6db9ee5eaf1ab278e2a67d250e3"},{"path":"packages/core/lib/LibTmux/Pane.pm","sha256":"1d34d763df3256c8645b91395788d0e863e1bff80115a473494b23c4525f3040"},{"path":"packages/core/lib/LibTmux/PaneSelection.pm","sha256":"6edb85943a642e56afcc5185b905c4fc82fcb9c3ca35d013aa61627421354fc5"},{"path":"packages/core/lib/LibTmux/Platform/Linux.pm","sha256":"15d720b545a11c3835e94b672bab6719fbc7dc6b9645ad5edb90207cb12a8968"},{"path":"packages/core/lib/LibTmux/ProcessJob.pm","sha256":"fd46908c18f4b034cd74b1c8e10b1525d7270e60159e32e6c45b0778425be642"},{"path":"packages/core/lib/LibTmux/QueryPlan.pm","sha256":"3f18a903100e46dcb58c32b7ad6a4853df8094f8932a56644b33d6e4dd5668fa"},{"path":"packages/core/lib/LibTmux/Schema.pm","sha256":"69290dbf72abe7cb27d9364b519f261281088d59abd4c17af33026adf4d7a52f"},{"path":"packages/core/lib/LibTmux/Selection.pm","sha256":"12565d289dcb00e13852d297cbd843a65a9bab43c0e6cab6392bc6fdf8749c99"},{"path":"packages/core/lib/LibTmux/Selection/Iterator.pm","sha256":"755aaf2aa31e3302422d00573bd4ce4d26be8017f1d008b12be1f64708496d40"},{"path":"packages/core/lib/LibTmux/Server.pm","sha256":"2ee3f86b2a377d31692321c19928845f49463a6faa1e231bf4fadb5825be23ef"},{"path":"packages/core/lib/LibTmux/Session.pm","sha256":"937f4399513d814108380b75beb1c8824960593354f3955559439e2bc999da83"},{"path":"packages/core/lib/LibTmux/SessionSelection.pm","sha256":"8ba23cdcf527ceb555ce392857c2b43b86b1b55ab4e881e5dc733ced99e95f4c"},{"path":"packages/core/lib/LibTmux/Snapshot.pm","sha256":"d25f65b94405c1d9cb3ff3f0e268de567d79d4aca178efa66c14db8bd040df5d"},{"path":"packages/core/lib/LibTmux/Transport.pm","sha256":"57dcb66db1c204f7fe6bcfee6623742dcfe425d8f9f0220e126d8e7c0a6535dc"},{"path":"packages/core/lib/LibTmux/Window.pm","sha256":"df01e902cc513dee0e7458c2499078ca9141446066a822525a2e45864942e06e"},{"path":"packages/core/lib/LibTmux/WindowLink.pm","sha256":"30c8937a5806bb2996af3b21c3a6936a383a3e34ead6d591748a077b7b6adebf"},{"path":"packages/core/lib/LibTmux/WindowLinkSelection.pm","sha256":"8301d518b97d620f76c7d1c7927c14809962a48b9ae5027768ea2163395550f1"},{"path":"packages/core/lib/LibTmux/WindowSelection.pm","sha256":"8b7956f6360344d3c3f8c7b1759f2e53e0acbbc98e81d2f3f864c339b8fcf8c2"},{"path":"packages/core/lib/LibTmux/X.pm","sha256":"83438781e81322c06006dd84fe7bf357472a34c1e3e3a502babdc5b040036195"},{"path":"packages/core/lib/LibTmux/schema.json","sha256":"5f132d204d5c919cdab5083233da5a1c0aedf4690f72fe430c1c8b1b271cb1e9"},{"path":"packages/async/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/async/Makefile.PL","sha256":"4b547f9c20d8c96d8ad7837a76f7ac63547714179ae988288762c268da9d169d"},{"path":"packages/async/README.md","sha256":"b3b9871187d30a2df31153dd8b906bffbd877bd5598b28c6445a0c998bd8aedb"},{"path":"packages/async/cpanfile","sha256":"9a4b450d72ad956fc35f73147fe7a003913f54143c88e8c52d2fab7230821555"},{"path":"packages/async/lib/LibTmux/Async.pm","sha256":"a17ae3cb757850a86ec7b40ddc59902fa74df36241066b63b2d38f2f2f161d84"},{"path":"packages/async/lib/LibTmux/Async/Server.pm","sha256":"65af3416d55200c0d10d4a2a8982280254ee28b5d06b15222a1da7da6beeea11"},{"path":"packages/async/lib/LibTmux/Async/Transport.pm","sha256":"67c30dd33016be2f7161aeaa4aab0ff3a153b06c8739a32fc9a8786642dc9375"},{"path":"packages/async/lib/LibTmux/Async/X.pm","sha256":"c1f342b52f45de5eee2c1970e806049a373f0f88d1c579ae4c157ed40756d272"},{"path":"packages/workspace/LICENSE","sha256":"e32e2d62046374e7f08a57882699e3f37920edf6b770f817e5b67eb625e2eb4f"},{"path":"packages/workspace/Makefile.PL","sha256":"36b4d47face444caff12f89598db6a70f66874237062305fb4fb2bfc11a39932"},{"path":"packages/workspace/README.md","sha256":"0c91daae67f82f31629102776e8e65b3634f29d5345c136825e4dfcb00915b19"},{"path":"packages/workspace/cpanfile","sha256":"0b5cd38aa2f1bd590cf8b00428c09adf8246f66ff66d861abd619648a8a9c8f3"},{"path":"packages/workspace/lib/LibTmux/Workspace.pm","sha256":"5201a40ede160f6f4931b475f753de3329280cc4c49469fab7242c7943f77aee"},{"path":"packages/workspace/lib/LibTmux/Workspace/X.pm","sha256":"10c8aeefee1eff75d303559f1a30d4a71705ba638fa95e630fad0b4df04c0220"},{"path":"examples/quickstart.pl","sha256":"ba9f650b81972f6b11556c4babd22b19d868335d9701980069e5d37748ce3cf2"},{"path":"examples/selection.pl","sha256":"2f558f90969300ba7d2b86dac55a07a23b140ea60c921a282ddf231e9dd98093"},{"path":"examples/workspace.pl","sha256":"6f0b49432880a956960fcc19c02fe1ed0c7eeb4f57f2131e17162c4ecb65fbf3"},{"path":"examples/async.pl","sha256":"f194d964b977c4249b06e6927cd2533a7725675cf4534377baa2d3e5ef1d9d9b"},{"path":"examples/await.pl","sha256":"4ba75608ce524ae2b0212c029bbdcb9d4d96c8aebfac5d96a227c48a28ef2294"}]},"symbols":[{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nUse :obj:`LibTmux::Server <LibTmux::Server>` for acquisition and commands. Captured entities and :obj:`LibTmux::Selection <LibTmux::Selection>` queries perform no tmux I/O.\n\n\n## DOCUMENTATION\n\n[Perl documentation](https://libtmux.org/en/perl/) provides installation, guides, and runnable examples. Read the [API reference](https://libtmux.org/en/perl/latest/reference/) or start with [Server](https://libtmux.org/en/perl/latest/reference/libtmux-server/). The [CPAN distribution](https://metacpan.org/dist/LibTmux) contains this POD and the consumer examples. The `0.x` API can change between releases.\n\n","summary":"Explicit tmux commands and captured graph queries"},"id":"LibTmux","kind":"module","modifiers":[],"name":"LibTmux","package":"LibTmux","product":"core","publicId":"LibTmux","qualifiedName":"LibTmux","signatures":[{"params":[],"raw":"package LibTmux;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nThe async distribution depends on :obj:`LibTmux <LibTmux>`, [IO::Async](https://metacpan.org/pod/IO::Async), [Future](https://metacpan.org/pod/Future), [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll), and [IO::Ppoll](https://metacpan.org/pod/IO::Ppoll). Use :obj:`LibTmux::Async::Server <LibTmux::Async::Server>` or :obj:`LibTmux::Async::Transport <LibTmux::Async::Transport>` with an explicitly supplied Ppoll loop. Core snapshot filtering remains local and synchronous. Async dependencies are not required by the core or workspace distributions.\n\n\n## DOCUMENTATION\n\nRead the [Perl documentation](https://libtmux.org/en/perl/) and [async guide](https://libtmux.org/en/perl/latest/guides/async/) for setup, concurrency, cancellation, and executor cleanup. The [API reference](https://libtmux.org/en/perl/latest/reference/libtmux-async-server/) documents Future-returning operations. The [CPAN distribution](https://metacpan.org/dist/LibTmux-Async) includes runnable consumer examples. The `0.x` API can change between releases.\n\n","summary":"Optional Future-based libtmux execution"},"id":"LibTmux::Async","kind":"module","modifiers":[],"name":"Async","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async","qualifiedName":"LibTmux::Async","signatures":[{"params":[],"raw":"package LibTmux::Async;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use IO::Async::Loop::Ppoll;\n    use LibTmux::Async::Server;\n    my $loop = IO::Async::Loop::Ppoll->new;\n    my $server = LibTmux::Async::Server->new(loop => $loop, socket_name => 'owned');\n    my $capture = $server->snapshot;\n    $loop->await($capture);\n    my $panes = $capture->get->panes->where({ active => true });\n    $loop->await($server->close);\n```\n\n","summary":"Optional Future facade over the core protocol","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse IO::Async::Loop::Ppoll;\nuse Future::AsyncAwait;\nuse LibTmux::Async::Server;\nuse LibTmuxFixture;\nasync sub capture_count ($server) {\n    my $snapshot = await $server->snapshot;\n    my $count    = $snapshot->panes->count;\n    await $server->close;\n    return $count;\n}\nLibTmuxFixture->run(\n    sub ($sync, $root) {\n        $sync->new_session(\n            name    => 'await-example',\n            command => ['/bin/sleep', '120']\n        );\n        my $loop   = IO::Async::Loop::Ppoll->new;\n        my $server = LibTmux::Async::Server->new(\n            loop        => $loop,\n            socket_path => \"$root/s\",\n            executable  => $ENV{LIBTMUX_TEST_TMUX} // 'tmux'\n        );\n        my $work = capture_count($server);\n        $loop->await($work);\n        die 'await result differs' unless $work->get == 1;\n        say 'optional caller await syntax: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/a1cab0324b600a5df6e34b92590b5c3bd8f79c69/examples/await.pl"}]},"id":"LibTmux::Async::Server","kind":"class","modifiers":[],"name":"Server","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::Server","qualifiedName":"LibTmux::Async::Server","signatures":[{"params":[],"raw":"package LibTmux::Async::Server;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"attach_argv\" in LibTmux::Server <LibTmux::Server::attach_argv>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::attach_argv","kind":"method","modifiers":["async"],"name":"attach_argv","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::attach_argv","qualifiedName":"LibTmux::Async::Server::attach_argv","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub attach_argv($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":88,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-attach_argv"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"batch\" in LibTmux::Server <LibTmux::Server::batch>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::batch","kind":"method","modifiers":["async"],"name":"batch","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::batch","qualifiedName":"LibTmux::Async::Server::batch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"requests"}],"raw":"sub batch($self, $requests)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":62,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-batch"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"capture_pane\" in LibTmux::Server <LibTmux::Server::capture_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::capture_pane","kind":"method","modifiers":["async"],"name":"capture_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::capture_pane","qualifiedName":"LibTmux::Async::Server::capture_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub capture_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":82,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-capture_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"clients\" in LibTmux::Server <LibTmux::Server::clients>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::clients","kind":"method","modifiers":["async"],"name":"clients","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::clients","qualifiedName":"LibTmux::Async::Server::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub clients($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":87,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-clients"},{"apiScope":"exported","doc":{"summary":"Cancel active operations, suppress subsequent command continuations, reject new operations, and return a fresh cleanup observer [Future](https://metacpan.org/pod/Future). Only successful `is_done` completion proves owned processes and pipes finished. Cancellation of an observer does not cancel cleanup. The caller must drive its borrowed loop through shutdown. No tmux server is destroyed by closing this facade."},"id":"LibTmux::Async::Server::close","kind":"method","modifiers":["async"],"name":"close","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::close","qualifiedName":"LibTmux::Async::Server::close","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub close($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":55,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-close"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"cmd\" in LibTmux::Server <LibTmux::Server::cmd>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::cmd","kind":"method","modifiers":["async"],"name":"cmd","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::cmd","qualifiedName":"LibTmux::Async::Server::cmd","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":20,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"argv","variadic":"positional"}],"raw":"sub cmd($self, @argv)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":60,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-cmd"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"delete_buffer\" in LibTmux::Server <LibTmux::Server::delete_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::delete_buffer","kind":"method","modifiers":["async"],"name":"delete_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::delete_buffer","qualifiedName":"LibTmux::Async::Server::delete_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub delete_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":103,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-delete_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"detach_client\" in LibTmux::Server <LibTmux::Server::detach_client>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::detach_client","kind":"method","modifiers":["async"],"name":"detach_client","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::detach_client","qualifiedName":"LibTmux::Async::Server::detach_client","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub detach_client($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-detach_client"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"execute\" in LibTmux::Server <LibTmux::Server::execute>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::execute","kind":"method","modifiers":["async"],"name":"execute","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::execute","qualifiedName":"LibTmux::Async::Server::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub execute($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":63,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-execute"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"explain_panes\" in LibTmux::Server <LibTmux::Server::explain_panes>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::explain_panes","kind":"method","modifiers":["async"],"name":"explain_panes","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::explain_panes","qualifiedName":"LibTmux::Async::Server::explain_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub explain_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":69,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-explain_panes"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"get_environment\" in LibTmux::Server <LibTmux::Server::get_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::get_environment","kind":"method","modifiers":["async"],"name":"get_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::get_environment","qualifiedName":"LibTmux::Async::Server::get_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":96,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-get_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"get_option\" in LibTmux::Server <LibTmux::Server::get_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::get_option","kind":"method","modifiers":["async"],"name":"get_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::get_option","qualifiedName":"LibTmux::Async::Server::get_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":91,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-get_option"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_pane\" in LibTmux::Server <LibTmux::Server::kill_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_pane","kind":"method","modifiers":["async"],"name":"kill_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_pane","qualifiedName":"LibTmux::Async::Server::kill_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":83,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-kill_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_server\" in LibTmux::Server <LibTmux::Server::kill_server>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_server","kind":"method","modifiers":["async"],"name":"kill_server","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_server","qualifiedName":"LibTmux::Async::Server::kill_server","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_server($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":86,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-kill_server"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_session\" in LibTmux::Server <LibTmux::Server::kill_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_session","kind":"method","modifiers":["async"],"name":"kill_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_session","qualifiedName":"LibTmux::Async::Server::kill_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-kill_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"kill_window\" in LibTmux::Server <LibTmux::Server::kill_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::kill_window","kind":"method","modifiers":["async"],"name":"kill_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::kill_window","qualifiedName":"LibTmux::Async::Server::kill_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":84,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-kill_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"link_window\" in LibTmux::Server <LibTmux::Server::link_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::link_window","kind":"method","modifiers":["async"],"name":"link_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::link_window","qualifiedName":"LibTmux::Async::Server::link_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub link_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":72,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-link_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"listings\" in LibTmux::Server <LibTmux::Server::listings>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::listings","kind":"method","modifiers":["async"],"name":"listings","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::listings","qualifiedName":"LibTmux::Async::Server::listings","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"kind"}],"raw":"sub listings($self, $kind)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":61,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-listings"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"move_window\" in LibTmux::Server <LibTmux::Server::move_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::move_window","kind":"method","modifiers":["async"],"name":"move_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::move_window","qualifiedName":"LibTmux::Async::Server::move_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub move_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":74,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-move_window"},{"apiScope":"exported","doc":{"summary":"`new(loop => $loop, %connection_options)` constructs without I/O. Borrow an [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll); connection options belong to :obj:`\"new\" in LibTmux::Server <LibTmux::Server::new>`. `max_concurrent` and `max_queue` configure the owned :obj:`LibTmux::Async::Transport <LibTmux::Async::Transport>`. Its :obj:`backend and signal contract <LibTmux::Async::Transport::new>` applies to this facade. No event loop is run implicitly."},"id":"LibTmux::Async::Server::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new","qualifiedName":"LibTmux::Async::Server::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-new"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"new_session\" in LibTmux::Server <LibTmux::Server::new_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::new_session","kind":"method","modifiers":["async"],"name":"new_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new_session","qualifiedName":"LibTmux::Async::Server::new_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":64,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-new_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"new_window\" in LibTmux::Server <LibTmux::Server::new_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::new_window","kind":"method","modifiers":["async"],"name":"new_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::new_window","qualifiedName":"LibTmux::Async::Server::new_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":65,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-new_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` for arguments, returned value, and completion. Its observer runs inline in void context; a returned [Future](https://metacpan.org/pod/Future) is ignored. Cancellation before the decision suppresses it. If the observer cancels its query or calls :obj:`\"close\" <LibTmux::Async::Server::close>`, cancellation takes precedence over subsequent return or exception delivery. Continue driving the loop until close cleanup completes."},"id":"LibTmux::Async::Server::query_panes","kind":"method","modifiers":["async"],"name":"query_panes","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::query_panes","qualifiedName":"LibTmux::Async::Server::query_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub query_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":68,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-query_panes"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"rename_session\" in LibTmux::Server <LibTmux::Server::rename_session>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::rename_session","kind":"method","modifiers":["async"],"name":"rename_session","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::rename_session","qualifiedName":"LibTmux::Async::Server::rename_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":18,"kind":"name","start":4},{"end":31,"kind":"parameter","parameter":0,"start":26}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":70,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-rename_session"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"rename_window\" in LibTmux::Server <LibTmux::Server::rename_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::rename_window","kind":"method","modifiers":["async"],"name":"rename_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::rename_window","qualifiedName":"LibTmux::Async::Server::rename_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":71,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-rename_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"resize_pane\" in LibTmux::Server <LibTmux::Server::resize_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::resize_pane","kind":"method","modifiers":["async"],"name":"resize_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::resize_pane","qualifiedName":"LibTmux::Async::Server::resize_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub resize_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":78,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-resize_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_layout\" in LibTmux::Server <LibTmux::Server::select_layout>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_layout","kind":"method","modifiers":["async"],"name":"select_layout","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_layout","qualifiedName":"LibTmux::Async::Server::select_layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_layout($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-select_layout"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_pane\" in LibTmux::Server <LibTmux::Server::select_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_pane","kind":"method","modifiers":["async"],"name":"select_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_pane","qualifiedName":"LibTmux::Async::Server::select_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":76,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-select_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"select_window\" in LibTmux::Server <LibTmux::Server::select_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::select_window","kind":"method","modifiers":["async"],"name":"select_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::select_window","qualifiedName":"LibTmux::Async::Server::select_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":75,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-select_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"send_keys\" in LibTmux::Server <LibTmux::Server::send_keys>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::send_keys","kind":"method","modifiers":["async"],"name":"send_keys","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::send_keys","qualifiedName":"LibTmux::Async::Server::send_keys","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_keys($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":80,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-send_keys"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"send_text\" in LibTmux::Server <LibTmux::Server::send_text>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::send_text","kind":"method","modifiers":["async"],"name":"send_text","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::send_text","qualifiedName":"LibTmux::Async::Server::send_text","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_text($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":81,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-send_text"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_buffer\" in LibTmux::Server <LibTmux::Server::set_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_buffer","kind":"method","modifiers":["async"],"name":"set_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_buffer","qualifiedName":"LibTmux::Async::Server::set_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":101,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-set_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_environment\" in LibTmux::Server <LibTmux::Server::set_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_environment","kind":"method","modifiers":["async"],"name":"set_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_environment","qualifiedName":"LibTmux::Async::Server::set_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":95,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-set_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_hook\" in LibTmux::Server <LibTmux::Server::set_hook>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_hook","kind":"method","modifiers":["async"],"name":"set_hook","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_hook","qualifiedName":"LibTmux::Async::Server::set_hook","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_hook($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":93,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-set_hook"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_option\" in LibTmux::Server <LibTmux::Server::set_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_option","kind":"method","modifiers":["async"],"name":"set_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_option","qualifiedName":"LibTmux::Async::Server::set_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":90,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-set_option"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"set_title\" in LibTmux::Server <LibTmux::Server::set_title>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::set_title","kind":"method","modifiers":["async"],"name":"set_title","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::set_title","qualifiedName":"LibTmux::Async::Server::set_title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_title($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":79,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-set_title"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"show_buffer\" in LibTmux::Server <LibTmux::Server::show_buffer>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::show_buffer","kind":"method","modifiers":["async"],"name":"show_buffer","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::show_buffer","qualifiedName":"LibTmux::Async::Server::show_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":102,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-show_buffer"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"show_hooks\" in LibTmux::Server <LibTmux::Server::show_hooks>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::show_hooks","kind":"method","modifiers":["async"],"name":"show_hooks","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::show_hooks","qualifiedName":"LibTmux::Async::Server::show_hooks","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_hooks($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":94,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-show_hooks"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for arguments, returned value, and completion.","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse IO::Async::Loop::Ppoll;\nuse LibTmux::Async::Server;\nuse LibTmuxFixture;\nLibTmuxFixture->run(\n    sub ($sync, $root) {\n        $sync->new_session(\n            name    => 'async-example',\n            command => ['/bin/sleep', '120']\n        );\n        my $loop   = IO::Async::Loop::Ppoll->new;\n        my $server = LibTmux::Async::Server->new(\n            loop           => $loop,\n            socket_path    => \"$root/s\",\n            executable     => $ENV{LIBTMUX_TEST_TMUX} // 'tmux',\n            max_concurrent => 2\n        );\n        my $snapshot = $server->snapshot;\n        $loop->await($snapshot);\n        die 'async snapshot missing pane'\n            unless $snapshot->get->panes->count == 1;\n        my $closed = $server->close;\n        $loop->await($closed);\n        die 'cleanup failed' unless $closed->is_done;\n        say 'async capture and cleanup: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/a1cab0324b600a5df6e34b92590b5c3bd8f79c69/examples/async.pl"}]},"id":"LibTmux::Async::Server::snapshot","kind":"method","modifiers":["async"],"name":"snapshot","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::snapshot","qualifiedName":"LibTmux::Async::Server::snapshot","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub snapshot($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":67,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-snapshot"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"split_pane\" in LibTmux::Server <LibTmux::Server::split_pane>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::split_pane","kind":"method","modifiers":["async"],"name":"split_pane","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::split_pane","qualifiedName":"LibTmux::Async::Server::split_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub split_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-split_pane"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unlink_window\" in LibTmux::Server <LibTmux::Server::unlink_window>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unlink_window","kind":"method","modifiers":["async"],"name":"unlink_window","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unlink_window","qualifiedName":"LibTmux::Async::Server::unlink_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unlink_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":73,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-unlink_window"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unset_environment\" in LibTmux::Server <LibTmux::Server::unset_environment>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unset_environment","kind":"method","modifiers":["async"],"name":"unset_environment","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unset_environment","qualifiedName":"LibTmux::Async::Server::unset_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":21,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":98,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-unset_environment"},{"apiScope":"exported","doc":{"summary":"See :obj:`\"unset_option\" in LibTmux::Server <LibTmux::Server::unset_option>` for arguments, returned value, and completion."},"id":"LibTmux::Async::Server::unset_option","kind":"method","modifiers":["async"],"name":"unset_option","package":"LibTmux-Async","parent":"LibTmux::Async::Server","product":"core","publicId":"LibTmux::Async::Server::unset_option","qualifiedName":"LibTmux::Async::Server::unset_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Server.pm","line":92,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-server-unset_option"},{"apiScope":"exported","doc":{"body":"","summary":"Bounded asynchronous process execution"},"id":"LibTmux::Async::Transport","kind":"class","modifiers":[],"name":"Transport","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::Transport","qualifiedName":"LibTmux::Async::Transport","signatures":[{"params":[],"raw":"package LibTmux::Async::Transport;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-transport"},{"apiScope":"exported","doc":{"summary":"Begin idempotent shutdown and return a fresh observer Future. New admissions fail with :obj:`Closed <LibTmux::Async::X::Closed>`; queued requests are cancelled without dispatch and running jobs are cancelled. Cancelling an observer never cancels private cleanup. Only successful `is_done` completion proves all owned jobs, pipes, and watchers have completed cleanup. The borrowed loop remains usable. Callers must keep driving it through shutdown."},"id":"LibTmux::Async::Transport::close","kind":"method","modifiers":[],"name":"close","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::close","qualifiedName":"LibTmux::Async::Transport::close","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub close($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":218,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-transport-close"},{"apiScope":"exported","doc":{"body":"The shared :obj:`LibTmux::ProcessJob <LibTmux::ProcessJob>` owns supervision. Cancelling the Future requests cleanup; it does not prove exit or reverse command effects.","summary":"Accepts the same literal process arguments as :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>`. Returns a [Future](https://metacpan.org/pod/Future) yielding one :obj:`command result <LibTmux::CommandResult>`. Typed core exceptions remain the failure value. Queue overflow fails with :obj:`QueueFull <LibTmux::Async::X::QueueFull>` before dispatch. The backend is checked again at admission and launch. Child preparation failures retain a typed diagnostic and `dispatched` false, with supervisor exit still required before cleanup completes."},"id":"LibTmux::Async::Transport::execute","kind":"method","modifiers":[],"name":"execute","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::execute","qualifiedName":"LibTmux::Async::Transport::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"request","variadic":"keyword"}],"raw":"sub execute($self, %request)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":60,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-transport-execute"},{"apiScope":"exported","doc":{"body":"Ppoll blocks watched signals outside its atomic wait. Its shared SIGCHLD watch can outlive this transport. `close` leaves the caller-selected loop and its signal policy intact. Do not change the backend or its wait mask while jobs or cleanup remain active. Async children unblock only SIGCHLD before process supervision; other mask bits remain unchanged in the child. This lets a new tmux daemon observe pane exits without changing synchronous core's mask policy.","summary":"`new(loop => $loop, max_concurrent => 4, max_queue => 64)` borrows an [IO::Async::Loop::Ppoll](https://metacpan.org/pod/IO::Async::Loop::Ppoll) backed by [IO::Ppoll](https://metacpan.org/pod/IO::Ppoll). Construct that class explicitly; automatic loop selection can choose an unsupported backend. Other classes, a substituted poll implementation, or a wait mask blocking SIGCHLD throw :obj:`Unsupported <LibTmux::X::Unsupported>` before dispatch. The loop owns supervisor reaping; competing external all-child reapers are unsupported. The library never runs, stops, or replaces it."},"id":"LibTmux::Async::Transport::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Async","parent":"LibTmux::Async::Transport","product":"core","publicId":"LibTmux::Async::Transport::new","qualifiedName":"LibTmux::Async::Transport::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/Transport.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-transport-new"},{"apiScope":"exported","doc":{"body":"","summary":"Shutdown has started and new work is refused. Callers may still observe cleanup through \"close\" in LibTmux::Async::Transport."},"id":"LibTmux::Async::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X","qualifiedName":"LibTmux::Async::X","signatures":[{"params":[],"raw":"package LibTmux::Async::X;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-x"},{"apiScope":"exported","doc":{"summary":"Shutdown has started and new work is refused. Callers may still observe cleanup through :obj:`\"close\" in LibTmux::Async::Transport <LibTmux::Async::Transport::close>`."},"id":"LibTmux::Async::X::Closed","kind":"exception","modifiers":[],"name":"Closed","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X::Closed","qualifiedName":"LibTmux::Async::X::Closed","signatures":[{"params":[],"raw":"package LibTmux::Async::X::Closed;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-x-closed"},{"apiScope":"exported","doc":{"summary":"The configured running and pending limits are occupied. No command was submitted for this request. Returned through a failed [Future](https://metacpan.org/pod/Future)."},"id":"LibTmux::Async::X::QueueFull","kind":"exception","modifiers":[],"name":"QueueFull","package":"LibTmux-Async","product":"core","publicId":"LibTmux::Async::X::QueueFull","qualifiedName":"LibTmux::Async::X::QueueFull","signatures":[{"params":[],"raw":"package LibTmux::Async::X::QueueFull;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/async/lib/LibTmux/Async/X.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-async-x-queuefull"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured client entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Client","kind":"class","modifiers":[],"name":"Client","package":"LibTmux","product":"core","publicId":"LibTmux::Client","qualifiedName":"LibTmux::Client","signatures":[{"params":[],"raw":"package LibTmux::Client;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Client::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::generation","qualifiedName":"LibTmux::Client::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::height","qualifiedName":"LibTmux::Client::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Client::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::id","qualifiedName":"LibTmux::Client::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Client::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::identity","qualifiedName":"LibTmux::Client::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Client::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::kind","qualifiedName":"LibTmux::Client::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Client::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::name","qualifiedName":"LibTmux::Client::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-name"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::pid","qualifiedName":"LibTmux::Client::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-pid"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Client::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::server_id","qualifiedName":"LibTmux::Client::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-server_id"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Session <LibTmux::Session>` entity or undef. Local captured data; no I/O."},"id":"LibTmux::Client::session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::session","qualifiedName":"LibTmux::Client::session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub session($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-session"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Client::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::to_record","qualifiedName":"LibTmux::Client::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-to_record"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Client::tty","kind":"method","modifiers":[],"name":"tty","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::tty","qualifiedName":"LibTmux::Client::tty","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub tty($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-tty"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Client::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::width","qualifiedName":"LibTmux::Client::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Client.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-client-width"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Client <LibTmux::Client>` handles from one server generation. Empty instances still validate against the client schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured client entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::ClientSelection","kind":"class","modifiers":[],"name":"ClientSelection","package":"LibTmux","product":"core","publicId":"LibTmux::ClientSelection","qualifiedName":"LibTmux::ClientSelection","signatures":[{"params":[],"raw":"package LibTmux::ClientSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ClientSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::ClientSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::count","qualifiedName":"LibTmux::ClientSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::ClientSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::exists","qualifiedName":"LibTmux::ClientSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::ClientSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::first","qualifiedName":"LibTmux::ClientSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::ClientSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::grep","qualifiedName":"LibTmux::ClientSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::ClientSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::iterator","qualifiedName":"LibTmux::ClientSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::ClientSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::new","qualifiedName":"LibTmux::ClientSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::ClientSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::one","qualifiedName":"LibTmux::ClientSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::ClientSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::one_or_undef","qualifiedName":"LibTmux::ClientSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::ClientSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::to_array","qualifiedName":"LibTmux::ClientSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::ClientSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::ClientSelection","product":"core","publicId":"LibTmux::ClientSelection::where","qualifiedName":"LibTmux::ClientSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-clientselection-where"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders are local and do not mutate the result or perform I/O. A lifecycle exception may expose a bounded partial result; it does not imply rollback or command completion. See :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>` and :obj:`LibTmux::X <LibTmux::X>`.\n\n","summary":"Completed or partial subprocess outcome"},"id":"LibTmux::CommandResult","kind":"class","modifiers":[],"name":"CommandResult","package":"LibTmux","product":"core","publicId":"LibTmux::CommandResult","qualifiedName":"LibTmux::CommandResult","signatures":[{"params":[],"raw":"package LibTmux::CommandResult;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult"},{"apiScope":"exported","doc":{"summary":"Return an exit code or undef when no child status is known."},"id":"LibTmux::CommandResult::exit_code","kind":"method","modifiers":[],"name":"exit_code","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::exit_code","qualifiedName":"LibTmux::CommandResult::exit_code","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub exit_code($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-exit_code"},{"apiScope":"exported","doc":{"summary":"Return the POSIX wait status or undef when unavailable."},"id":"LibTmux::CommandResult::raw_status","kind":"method","modifiers":[],"name":"raw_status","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::raw_status","qualifiedName":"LibTmux::CommandResult::raw_status","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub raw_status($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-raw_status"},{"apiScope":"exported","doc":{"summary":"Return a terminating signal number, zero for ordinary exit, or undef for unknown status."},"id":"LibTmux::CommandResult::signal","kind":"method","modifiers":[],"name":"signal","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::signal","qualifiedName":"LibTmux::CommandResult::signal","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub signal($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-signal"},{"apiScope":"exported","doc":{"summary":"Return separately retained stderr octets, possibly empty."},"id":"LibTmux::CommandResult::stderr","kind":"method","modifiers":[],"name":"stderr","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::stderr","qualifiedName":"LibTmux::CommandResult::stderr","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub stderr($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":4,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-stderr"},{"apiScope":"exported","doc":{"summary":"Return retained stdout octets, possibly empty. No text decoding occurs."},"id":"LibTmux::CommandResult::stdout","kind":"method","modifiers":[],"name":"stdout","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::stdout","qualifiedName":"LibTmux::CommandResult::stdout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub stdout($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":3,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-stdout"},{"apiScope":"exported","doc":{"summary":"Return true only when known status proves ordinary exit zero. Unknown status is never success."},"id":"LibTmux::CommandResult::success","kind":"method","modifiers":[],"name":"success","package":"LibTmux","parent":"LibTmux::CommandResult","product":"core","publicId":"LibTmux::CommandResult::success","qualifiedName":"LibTmux::CommandResult::success","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub success($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/CommandResult.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-commandresult-success"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nField readers and relationships resolve locally in the retained graph. :obj:`\"to_record\" <LibTmux::Entity::to_record>` returns detached scalar record data. Handles retain no transport.\n\n\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Read-only handle retaining a captured graph"},"id":"LibTmux::Entity","kind":"class","modifiers":[],"name":"Entity","package":"LibTmux","product":"core","publicId":"LibTmux::Entity","qualifiedName":"LibTmux::Entity","signatures":[{"params":[],"raw":"package LibTmux::Entity;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Entity::generation","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::generation","qualifiedName":"LibTmux::Entity::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity-generation"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Entity::identity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::identity","qualifiedName":"LibTmux::Entity::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Entity::kind","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::kind","qualifiedName":"LibTmux::Entity::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity-kind"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Entity::server_id","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::server_id","qualifiedName":"LibTmux::Entity::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Entity::to_record","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Entity","product":"core","publicId":"LibTmux::Entity::to_record","qualifiedName":"LibTmux::Entity::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-entity-to_record"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use LibTmux::Filter;\n    my $filter = LibTmux::Filter->new(\n        entity => 'pane', where => {width => {-gte => 120}},\n    );\n    my $matches = $snapshot->panes->where($filter);\n```\n\n\n## CONTRACT\n\nCompilation validates the entire tree and copies operands. Hash keys evaluate lexically; logical arrays retain input order. Missing reads throw; known-null ordering is false. String operators are literal. Relations use some/every/none and is/is_not with explicit dash prefixes in Perl data.\n\n`matches` accepts entities, plain records, and registered adapters. `to_data`/`to_json` export copies in libtmux.where/v1; `from_data`/`from_json` validate input. Regex/coderefs/cycles and non-UTF-8 byte-path wire operands are refused. Perl regex remains available through Selection `grep`.\n\n\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Validated, reusable local criteria and explicit wire data"},"id":"LibTmux::Filter","kind":"class","modifiers":[],"name":"Filter","package":"LibTmux","product":"core","publicId":"LibTmux::Filter","qualifiedName":"LibTmux::Filter","signatures":[{"params":[],"raw":"package LibTmux::Filter;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter"},{"apiScope":"exported","doc":{"summary":"Return the declared entity-kind string. It remains known for an empty :obj:`LibTmux::Selection <LibTmux::Selection>`."},"id":"LibTmux::Filter::entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::entity","qualifiedName":"LibTmux::Filter::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-entity"},{"apiScope":"exported","doc":{"summary":"`from_data($envelope)` validates the version, entity, fields, operators, and operands, then returns a compiled filter. Reject executable values, unknown versions, cycles, and unsupported regex nodes."},"id":"LibTmux::Filter::from_data","kind":"method","modifiers":[],"name":"from_data","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::from_data","qualifiedName":"LibTmux::Filter::from_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"data"}],"raw":"sub from_data($class, $data)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":315,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-from_data"},{"apiScope":"exported","doc":{"summary":"`from_json($json_octets)` decodes bounded JSON using core booleans and calls :obj:`\"from_data\" <LibTmux::Filter::from_data>`. Invalid JSON throws :obj:`InvalidFilter <LibTmux::X::InvalidFilter>`."},"id":"LibTmux::Filter::from_json","kind":"method","modifiers":[],"name":"from_json","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::from_json","qualifiedName":"LibTmux::Filter::from_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"bytes"}],"raw":"sub from_json($class, $bytes)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":331,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-from_json"},{"apiScope":"exported","doc":{"summary":"`matches($entity_or_record)` returns a native Boolean. Accept captured entities, plain hash records, or registered adapters of the declared kind. Missing required reads throw :obj:`Unloaded <LibTmux::X::Unloaded>`; they never become null or false through negation. Evaluation performs no I/O."},"id":"LibTmux::Filter::matches","kind":"method","modifiers":[],"name":"matches","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::matches","qualifiedName":"LibTmux::Filter::matches","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"record"}],"raw":"sub matches($self, $record)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":136,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-matches"},{"apiScope":"exported","doc":{"summary":"`new(entity => kind, where => $hashref)` validates the complete criteria tree and owns a normalized copy. Schemas choose comparison types; no scalar-history coercion or arbitrary method dispatch occurs. Errors throw :obj:`InvalidFilter <LibTmux::X::InvalidFilter>` with precise paths, even for unreachable branches."},"id":"LibTmux::Filter::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::new","qualifiedName":"LibTmux::Filter::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-new"},{"apiScope":"exported","doc":{"summary":"Return an independent copy of normalized Perl criteria. Editing it does not change the compiled filter."},"id":"LibTmux::Filter::normalized_where","kind":"method","modifiers":[],"name":"normalized_where","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::normalized_where","qualifiedName":"LibTmux::Filter::normalized_where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4}],"params":[],"raw":"sub normalized_where($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-normalized_where"},{"apiScope":"exported","doc":{"summary":"`register_adapter(class => name, entity => kind, readers => { field => coderef })` registers trusted field readers without inheritance. Only declared fields are accepted. Readers are executable local code; they never enter portable criteria. See :obj:`LibTmux::Schema <LibTmux::Schema>`."},"id":"LibTmux::Filter::register_adapter","kind":"method","modifiers":[],"name":"register_adapter","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::register_adapter","qualifiedName":"LibTmux::Filter::register_adapter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub register_adapter($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":20,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-register_adapter"},{"apiScope":"exported","doc":{"summary":"Return a fresh `libtmux.where/v1` envelope using canonical wire field/operator names. Normalize strings, numbers, native booleans, null, objects, and arrays by schema. Aliases are currently absent; one canonical name is encoded."},"id":"LibTmux::Filter::to_data","kind":"method","modifiers":[],"name":"to_data","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::to_data","qualifiedName":"LibTmux::Filter::to_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":301,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-to_data"},{"apiScope":"exported","doc":{"summary":"Return canonical-key UTF-8 JSON octets using [JSON::PP](https://perldoc.perl.org/5.44.0/JSON::PP). Non-UTF-8 opaque path bytes throw :obj:`UnsupportedValue <LibTmux::X::UnsupportedValue>`. This is reproducible key order, not semantic canonicalization of arbitrary Boolean trees."},"id":"LibTmux::Filter::to_json","kind":"method","modifiers":[],"name":"to_json","package":"LibTmux","parent":"LibTmux::Filter","product":"core","publicId":"LibTmux::Filter::to_json","qualifiedName":"LibTmux::Filter::to_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_json($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Filter.pm","line":311,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-filter-to_json"},{"apiScope":"exported","doc":{"body":"","summary":"Executor-independent prepared command continuations"},"id":"LibTmux::Operation","kind":"class","modifiers":[],"name":"Operation","package":"LibTmux","product":"core","publicId":"LibTmux::Operation","qualifiedName":"LibTmux::Operation","signatures":[{"params":[],"raw":"package LibTmux::Operation;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation"},{"apiScope":"exported","doc":{"summary":"Recover a failure with one value or another Operation."},"id":"LibTmux::Operation::catch","kind":"method","modifiers":[],"name":"catch","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::catch","qualifiedName":"LibTmux::Operation::catch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"callback"}],"raw":"sub catch($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":33,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-catch"},{"apiScope":"exported","doc":{"summary":"`request(argv => [...], stdin => $octets, ...)` owns its input arguments. Execution is explicit through :obj:`\"run\" <LibTmux::Operation::run>`; preparation performs no I/O."},"id":"LibTmux::Operation::request","kind":"method","modifiers":[],"name":"request","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::request","qualifiedName":"LibTmux::Operation::request","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"request","variadic":"keyword"}],"raw":"sub request($class, %request)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-request"},{"apiScope":"exported","doc":{"body":"The synchronous :obj:`LibTmux::Server <LibTmux::Server>` and optional async distribution use the same preparation, codecs, and graph semantics. Core has no Future dependency.","summary":"`run($executor, $on_done, $on_fail)` supplies requests and two one-argument completion callbacks to the executor. The executor returns a cancellation hook. `run` returns a cancellation coderef suppressing further submissions. Each request settles once; the complete operation yields one value or error."},"id":"LibTmux::Operation::run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::run","qualifiedName":"LibTmux::Operation::run","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15},{"end":31,"kind":"parameter","parameter":1,"start":26},{"end":38,"kind":"parameter","parameter":2,"start":33}],"params":[{"name":"executor"},{"name":"done"},{"name":"fail"}],"raw":"sub run($self, $executor, $done, $fail)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":51,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-run"},{"apiScope":"exported","doc":{"summary":"Execute an array of Operations in order, returning one arrayref of results."},"id":"LibTmux::Operation::sequence","kind":"method","modifiers":[],"name":"sequence","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::sequence","qualifiedName":"LibTmux::Operation::sequence","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"operations"}],"raw":"sub sequence($class, $operations)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-sequence"},{"apiScope":"exported","doc":{"summary":"Compose a local transformation returning one value or another Operation. Exceptions retain their original identity."},"id":"LibTmux::Operation::then","kind":"method","modifiers":[],"name":"then","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::then","qualifiedName":"LibTmux::Operation::then","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub then($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":27,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-then"},{"apiScope":"exported","doc":{"summary":"Wrap one local value, including undef for a documented void operation."},"id":"LibTmux::Operation::value","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Operation","product":"core","publicId":"LibTmux::Operation::value","qualifiedName":"LibTmux::Operation::value","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"value"}],"raw":"sub value($class, $value)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Operation.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-operation-value"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured pane entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Pane","kind":"class","modifiers":[],"name":"Pane","package":"LibTmux","product":"core","publicId":"LibTmux::Pane","qualifiedName":"LibTmux::Pane","signatures":[{"params":[],"raw":"package LibTmux::Pane;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::Pane::active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::active","qualifiedName":"LibTmux::Pane::active","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub active($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-active"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::current_command","kind":"method","modifiers":[],"name":"current_command","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::current_command","qualifiedName":"LibTmux::Pane::current_command","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4}],"params":[],"raw":"sub current_command($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-current_command"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Pane::current_path","kind":"method","modifiers":[],"name":"current_path","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::current_path","qualifiedName":"LibTmux::Pane::current_path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub current_path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-current_path"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::cursor_shape","kind":"method","modifiers":[],"name":"cursor_shape","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::cursor_shape","qualifiedName":"LibTmux::Pane::cursor_shape","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub cursor_shape($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-cursor_shape"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::Pane::dead","kind":"method","modifiers":[],"name":"dead","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::dead","qualifiedName":"LibTmux::Pane::dead","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub dead($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-dead"},{"apiScope":"exported","doc":{"summary":"integer or undef. Local captured data; no I/O."},"id":"LibTmux::Pane::exit_status","kind":"method","modifiers":[],"name":"exit_status","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::exit_status","qualifiedName":"LibTmux::Pane::exit_status","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub exit_status($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-exit_status"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Pane::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::generation","qualifiedName":"LibTmux::Pane::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::height","qualifiedName":"LibTmux::Pane::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::id","qualifiedName":"LibTmux::Pane::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Pane::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::identity","qualifiedName":"LibTmux::Pane::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-identity"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::index","qualifiedName":"LibTmux::Pane::index","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub index($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-index"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Pane::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::kind","qualifiedName":"LibTmux::Pane::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-kind"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::pid","qualifiedName":"LibTmux::Pane::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-pid"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Pane::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::server_id","qualifiedName":"LibTmux::Pane::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-server_id"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Pane::title","kind":"method","modifiers":[],"name":"title","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::title","qualifiedName":"LibTmux::Pane::title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub title($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-title"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Pane::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::to_record","qualifiedName":"LibTmux::Pane::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-to_record"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Pane::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::width","qualifiedName":"LibTmux::Pane::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-width"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Window <LibTmux::Window>` entity. Local captured data; no I/O."},"id":"LibTmux::Pane::window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::Pane","product":"core","publicId":"LibTmux::Pane::window","qualifiedName":"LibTmux::Pane::window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub window($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Pane.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-pane-window"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Pane <LibTmux::Pane>` handles from one server generation. Empty instances still validate against the pane schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured pane entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::PaneSelection","kind":"class","modifiers":[],"name":"PaneSelection","package":"LibTmux","product":"core","publicId":"LibTmux::PaneSelection","qualifiedName":"LibTmux::PaneSelection","signatures":[{"params":[],"raw":"package LibTmux::PaneSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/PaneSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::PaneSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::count","qualifiedName":"LibTmux::PaneSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::PaneSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::exists","qualifiedName":"LibTmux::PaneSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::PaneSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::first","qualifiedName":"LibTmux::PaneSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::PaneSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::grep","qualifiedName":"LibTmux::PaneSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::PaneSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::iterator","qualifiedName":"LibTmux::PaneSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::PaneSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::new","qualifiedName":"LibTmux::PaneSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::PaneSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::one","qualifiedName":"LibTmux::PaneSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::PaneSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::one_or_undef","qualifiedName":"LibTmux::PaneSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::PaneSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::to_array","qualifiedName":"LibTmux::PaneSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::PaneSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::PaneSelection","product":"core","publicId":"LibTmux::PaneSelection::where","qualifiedName":"LibTmux::PaneSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-paneselection-where"},{"apiScope":"exported","doc":{"body":"","summary":"Shared owned process-supervision boundary"},"id":"LibTmux::ProcessJob","kind":"class","modifiers":[],"name":"ProcessJob","package":"LibTmux","product":"core","publicId":"LibTmux::ProcessJob","qualifiedName":"LibTmux::ProcessJob","signatures":[{"params":[],"raw":"package LibTmux::ProcessJob;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob"},{"apiScope":"exported","doc":{"summary":"Request cleanup without blocking. Cancellation can follow dispatch and does not imply rollback or completed reaping."},"id":"LibTmux::ProcessJob::cancel","kind":"method","modifiers":[],"name":"cancel","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::cancel","qualifiedName":"LibTmux::ProcessJob::cancel","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub cancel($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":108,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-cancel"},{"apiScope":"exported","doc":{"summary":"True only after a valid supervisor result proves owned program cleanup."},"id":"LibTmux::ProcessJob::cleanup_complete","kind":"method","modifiers":[],"name":"cleanup_complete","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::cleanup_complete","qualifiedName":"LibTmux::ProcessJob::cleanup_complete","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4}],"params":[],"raw":"sub cleanup_complete($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":99,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-cleanup_complete"},{"apiScope":"exported","doc":{"summary":"Accumulate bounded result octets. Malformed or excessive data is a failure."},"id":"LibTmux::ProcessJob::consume","kind":"method","modifiers":[],"name":"consume","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::consume","qualifiedName":"LibTmux::ProcessJob::consume","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"bytes"}],"raw":"sub consume($self, $bytes)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-consume"},{"apiScope":"exported","doc":{"summary":"Decode the complete result after EOF and supervisor exit. Return one :obj:`LibTmux::CommandResult <LibTmux::CommandResult>` or throw a typed error."},"id":"LibTmux::ProcessJob::finish","kind":"method","modifiers":[],"name":"finish","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::finish","qualifiedName":"LibTmux::ProcessJob::finish","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub finish($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":128,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-finish"},{"apiScope":"exported","doc":{"summary":"Return the supervisor PID. It differs from the program PID."},"id":"LibTmux::ProcessJob::pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::pid","qualifiedName":"LibTmux::ProcessJob::pid","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4}],"params":[],"raw":"sub pid($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":98,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-pid"},{"apiScope":"exported","doc":{"summary":"Start a supervised literal command using the same arguments as :obj:`\"run\" in LibTmux::Transport <LibTmux::Transport::run>`. This explicit operation performs I/O."},"id":"LibTmux::ProcessJob::start","kind":"method","modifiers":[],"name":"start","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::start","qualifiedName":"LibTmux::ProcessJob::start","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"input","variadic":"keyword"}],"raw":"sub start($class, %input)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-start"},{"apiScope":"exported","doc":{"summary":"Transfer the result pipe exactly once. Its reader owns closing that handle."},"id":"LibTmux::ProcessJob::take_result_handle","kind":"method","modifiers":[],"name":"take_result_handle","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::take_result_handle","qualifiedName":"LibTmux::ProcessJob::take_result_handle","signatures":[{"methodKind":"call","nativeSyntax":[{"end":22,"kind":"name","start":4}],"params":[],"raw":"sub take_result_handle($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":101,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-take_result_handle"},{"apiScope":"exported","doc":{"summary":"The synchronous reader/reaper. A loop-owned job refuses blocking wait. Async adapters supply a spawn/reap callback and retain jobs through EOF plus the matching exit notification. Dropping a job closes its parent guard but does not synchronously wait; owners must complete their cleanup protocol."},"id":"LibTmux::ProcessJob::wait","kind":"method","modifiers":[],"name":"wait","package":"LibTmux","parent":"LibTmux::ProcessJob","product":"core","publicId":"LibTmux::ProcessJob::wait","qualifiedName":"LibTmux::ProcessJob::wait","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub wait($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/ProcessJob.pm","line":200,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-processjob-wait"},{"apiScope":"exported","doc":{"body":"","summary":"Explainable explicit pane acquisition"},"id":"LibTmux::QueryPlan","kind":"class","modifiers":[],"name":"QueryPlan","package":"LibTmux","product":"core","publicId":"LibTmux::QueryPlan","qualifiedName":"LibTmux::QueryPlan","signatures":[{"params":[],"raw":"package LibTmux::QueryPlan;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-queryplan"},{"apiScope":"exported","doc":{"summary":"Return the compiled :obj:`LibTmux::Filter <LibTmux::Filter>`. Its matching remains local."},"id":"LibTmux::QueryPlan::filter","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::filter","qualifiedName":"LibTmux::QueryPlan::filter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub filter($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":31,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-queryplan-filter"},{"apiScope":"exported","doc":{"summary":"Return auto, never, or require. :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` executes the plan with complete captured local evaluation. Native candidates cannot hide errors or discard matches from that captured result. Only verified complete translation qualifies for require; runtime disagreement throws :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` without assigning a cause. The optional :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` observer exposes completed comparisons."},"id":"LibTmux::QueryPlan::policy","kind":"method","modifiers":[],"name":"policy","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::policy","qualifiedName":"LibTmux::QueryPlan::policy","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub policy($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":32,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-queryplan-policy"},{"apiScope":"exported","doc":{"summary":"Describe native lowering and local residual reasons. Explanation performs no I/O and uses the support floor until connected capabilities are available."},"id":"LibTmux::QueryPlan::summary","kind":"method","modifiers":[],"name":"summary","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::summary","qualifiedName":"LibTmux::QueryPlan::summary","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub summary($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":191,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-queryplan-summary"},{"apiScope":"exported","doc":{"summary":"Return an inspectable plan with source commands, filter, policy, and reasons. The :obj:`LibTmux::Schema <LibTmux::Schema>` catalog identifies required fields and relations."},"id":"LibTmux::QueryPlan::to_data","kind":"method","modifiers":[],"name":"to_data","package":"LibTmux","parent":"LibTmux::QueryPlan","product":"core","publicId":"LibTmux::QueryPlan::to_data","qualifiedName":"LibTmux::QueryPlan::to_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub to_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/QueryPlan.pm","line":235,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-queryplan-to_data"},{"apiScope":"exported","doc":{"body":"","summary":"Catalog and explicit record adapters"},"id":"LibTmux::Schema","kind":"class","modifiers":[],"name":"Schema","package":"LibTmux","product":"core","publicId":"LibTmux::Schema","qualifiedName":"LibTmux::Schema","signatures":[{"params":[],"raw":"package LibTmux::Schema;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Schema.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-schema"},{"apiScope":"exported","doc":{"summary":"`register_adapter(class => ..., entity => ..., readers => {...})` registers trusted callbacks for declared fields. Unknown criteria keys never become method names. Missing fields throw; nullable undef is known null."},"id":"LibTmux::Schema::register_adapter","kind":"method","modifiers":[],"name":"register_adapter","package":"LibTmux","parent":"LibTmux::Schema","product":"core","publicId":"LibTmux::Schema::register_adapter","qualifiedName":"LibTmux::Schema::register_adapter","signatures":[{"methodKind":"call","nativeSyntax":[{"end":20,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub register_adapter($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Schema.pm","line":121,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-schema-register_adapter"},{"apiScope":"exported","doc":{"body":"\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Native array selections with fixed query returns","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Filter;\nuse List::Util qw(any first);\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $session = $server->new_session(\n            name    => 'example',\n            command => ['/bin/sleep', '120']\n        );\n        my $initial = $session->window_links->one->window->panes->one;\n        $server->split_pane(\n            pane       => $initial,\n            horizontal => true,\n            command    => ['/bin/sleep', '120']\n        );\n        my $snapshot = $server->snapshot;\n        my $panes    = $snapshot->panes->where({current_command => 'sleep'})\n            ->grep(sub ($pane) { $pane->width >= 1 });\n        die 'expected two panes' unless $panes->count == 2;\n        for my $pane ($panes->@*) {\n            say $pane->id . ' ' . $pane->current_command;\n        }\n        my $only_active = $panes->one({active => true});\n        die 'active pane unavailable' unless defined $only_active;\n        my $has_active   = any { $_->active } $panes->@*;\n        my $first_active = first { $_->active } $panes->@*;\n        die 'List::Util alternatives differ'\n            unless $has_active && $first_active->id eq $only_active->id;\n        my @ids      = map  { $_->id } $panes->@*;\n        my @positive = grep { $_->width > 0 } $panes->@*;\n        die 'ordinary Perl arrays differ' unless @ids == 2 && @positive == 2;\n        my $filter =\n            LibTmux::Filter->new(entity => 'pane', where => {active => true});\n        my $decoded = LibTmux::Filter->from_json($filter->to_json);\n        die 'wire filter changed meaning'\n            unless $panes->where($decoded)->one->id eq $only_active->id;\n        my $retained = do {\n            my $observed = $server->snapshot;\n            $observed->pane_by_id($only_active->id);\n        };\n        die 'retained graph lost a relationship'\n            unless $retained->window->panes->count == 2;\n        my $same_child = $snapshot->windows->where(\n            {panes => {-some => {-and => [{index => 0}, {index => 1}]}}});\n        my $different_children = $snapshot->windows->where(\n            {\n                -and => [\n                    {panes => {-some => {index => 0}}},\n                    {panes => {-some => {index => 1}}}\n                ]\n            }\n        );\n        die 'quantifiers conflated children'\n            unless $same_child->count == 0 && $different_children->count == 1;\n        my $where = {active => true, width => {-gte => 1}};\n        my $local = $server->query_panes(where => $where, pushdown => 'never');\n        my $verification;\n        my $native = $server->query_panes(\n            where           => $where,\n            pushdown        => 'require',\n            on_verification => sub ($report) { $verification = $report },\n        );\n        die 'native verification was not observed'\n            unless $verification->{status} eq 'agreed'\n            && $verification->{comparison} eq 'exact_ids';\n        die 'native/local disagreement'\n            unless join(',', map { $_->id } @$local) eq\n            join(',', map { $_->id } @$native);\n        say 'selection, wire, graph lifetime, quantifiers, and query: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/a1cab0324b600a5df6e34b92590b5c3bd8f79c69/examples/selection.pl"}]},"id":"LibTmux::Selection","kind":"class","modifiers":[],"name":"Selection","package":"LibTmux","product":"core","publicId":"LibTmux::Selection","qualifiedName":"LibTmux::Selection","signatures":[{"params":[],"raw":"package LibTmux::Selection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection"},{"apiScope":"exported","doc":{"body":"","summary":"Local cursor over frozen membership"},"id":"LibTmux::Selection::Iterator","kind":"class","modifiers":[],"name":"Iterator","package":"LibTmux","product":"core","publicId":"LibTmux::Selection::Iterator","qualifiedName":"LibTmux::Selection::Iterator","signatures":[{"params":[],"raw":"package LibTmux::Selection::Iterator;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection/Iterator.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-iterator-cvun"},{"apiScope":"exported","doc":{"summary":"Return the next captured entity or undef only at exhaustion. Order and multiplicity match creation-time membership. Later native selection edits do not change this traversal. A cursor is consumable; create a fresh cursor with :obj:`\"iterator\" in LibTmux::Selection <LibTmux::Selection::iterator>` to traverse again. No tmux I/O occurs."},"id":"LibTmux::Selection::Iterator::next","kind":"method","modifiers":[],"name":"next","package":"LibTmux","parent":"LibTmux::Selection::Iterator","product":"core","publicId":"LibTmux::Selection::Iterator::next","qualifiedName":"LibTmux::Selection::Iterator::next","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub next($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection/Iterator.pm","line":4,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-iterator-next"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::Selection::count","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::count","qualifiedName":"LibTmux::Selection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::Selection::exists","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::exists","qualifiedName":"LibTmux::Selection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::Selection::first","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::first","qualifiedName":"LibTmux::Selection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::Selection::grep","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::grep","qualifiedName":"LibTmux::Selection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::Selection::iterator","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::iterator","qualifiedName":"LibTmux::Selection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-iterator-2bn1"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::Selection::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::new","qualifiedName":"LibTmux::Selection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::Selection::one","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::one","qualifiedName":"LibTmux::Selection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::Selection::one_or_undef","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::one_or_undef","qualifiedName":"LibTmux::Selection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::Selection::to_array","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::to_array","qualifiedName":"LibTmux::Selection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::Selection::where","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::where","qualifiedName":"LibTmux::Selection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-selection-where"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use v5.44;\n    use LibTmux::Server;\n    my $server = LibTmux::Server->new(socket_name => 'application');\n    my $snapshot = $server->snapshot;\n    my $pane = $snapshot->panes->first;\n    say $server->capture_pane(pane => $pane) if defined $pane;\n```\n\n\n## CONTRACT\n\nConstruction and planning perform no I/O. Acquisition and mutation are explicit, bounded operations. Captured :obj:`LibTmux::Snapshot <LibTmux::Snapshot>` entities retain their observed graph; mutations do not refresh them. Acquire another snapshot to observe changes. Connection settings remain owned by the server wrapper; destroying it never kills a tmux daemon. See the [orchestration guide](https://github.com/libtmux/libtmux-perl/blob/master/docs/orchestration.md).\n\nPhysical entity targets accept stable ID strings or generation-checked handles. Session-relative window operations require :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`. Checks across subprocesses are optimistic rather than transactional. Single-quote session IDs such as `'$1'` to avoid interpolating a Perl capture variable.\n\n\n## ERRORS\n\nInvalid arguments throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` before dispatch. Acquisition and checked commands propagate typed :obj:`LibTmux::X <LibTmux::X>` failures, including missing executables, absent daemons, vanished targets, stale handles, codec errors, timeouts, and output limits. Failures never become empty selections. Cancellation or a timeout after dispatch does not prove nonexecution or roll back effects.\n\n\n## VERIFICATION REPORT\n\n:obj:`\"query_panes\" <LibTmux::Server::query_panes>` supplies a fresh, detached hashref to `on_verification`. It contains no entity handles. Every ID array retains stable order; editing the report cannot mutate captured data or the query result.\n\n`policy`, `status`, `comparison`Policy is auto, never, require, or native for the expert escape hatch. Status is disabled (never), local (no safe lowering), agreed, disagreed, or native. Comparison is none, exact_ids, candidate_superset, or captured_membership. Partial lowering checks inclusion of local matches; expert queries check only membership in the captured graph. Neither establishes full filter equivalence.`native_checked`, `translation_exact`, `native_filter`, `reasons`native_checked is Boolean. translation_exact is Boolean, or undef for never and expert queries. native_filter is the executed expression, or undef when no native check ran. reasons is a fresh arrayref of lowering limitations. Exact translation and agreement between two observations are separate facts.`server_id`, `generation`, `daemon_version`, `capture_start`, `capture_end`Identity strings and the captured interval in wall-clock seconds since the epoch, from :obj:`\"metadata\" in LibTmux::Snapshot <LibTmux::Snapshot::metadata>`. This is not an atomic observation.`captured_ids`, `local_ids`, `native_ids`captured_ids and local_ids follow physical capture order; local_ids is undef for expert queries. native_ids holds unique IDs in native first-occurrence order, or undef when no check ran. An empty array is an observed empty set.`missing_ids`, `unexpected_ids`, `uncaptured_ids`missing_ids lists local matches absent natively, in local order. For exact lowering, unexpected_ids lists native matches absent locally. uncaptured_ids lists native IDs absent from the graph. The latter two follow native order; inapplicable lists are empty. Any applicable mismatch produces disagreed. :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` carries this report for require or expert failures; the observer is not called for a failed query. A discrepancy has no inferred cause: concurrent changes, compiler defects and backend differences all need investigation.\n\n","summary":"Explicit tmux acquisition and commands","examples":[{"lang":"perl","code":"use v5.44;\nuse Config;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\n\n# This complete demo owns a Linux child-reaping scope, including tmux panes.\nBEGIN {\n    die 'Requires Linux x86_64 LP64'\n        unless $^O eq 'linux'\n        && $Config::Config{archname} =~ /x86_64/\n        && $Config::Config{ptrsize} == 8\n        && $Config::Config{ivsize} == 8;\n    syscall(157, 36, 1, 0, 0, 0) == 0 or die \"subreaper: $!\";\n}\n\ntry {\n    LibTmuxFixture->run(\n        sub ($server, $root) {\n            my $session = $server->new_session(\n                name    => 'demo',\n                command => ['/bin/cat']\n            );\n            my $failure;\n            try {\n                my $editor = $session->window_links->one->window;\n                $server->rename_window(window => $editor, name => 'editor');\n                my $right = $server->split_pane(\n                    pane       => $editor->panes->one,\n                    horizontal => true,\n                    command    => ['/bin/cat']\n                );\n                my $logs = $server->new_window(\n                    session => $session,\n                    name    => 'logs',\n                    command => ['/bin/cat']\n                );\n                $server->select_pane(pane => $right);\n                my $snapshot = $server->snapshot;\n                my $link     = $snapshot->window_links->one(\n                    {\n                        window => {-is => {id => $logs->id}}\n                    }\n                );\n                $server->select_window(link => $link);\n                $snapshot = $server->snapshot;\n\n                for my $entry ($snapshot->sessions->@*) {\n                    say 'session ', $entry->name;\n                    for my $link ($entry->window_links->@*) {\n                        my $window = $link->window;\n                        my $ids   = join ' ', map { $_->id } $window->panes->@*;\n                        my $label = $link->index . ':' . $window->name;\n                        say '  window ', $label, ': ', $ids;\n                    }\n                }\n                my $panes =\n                    $snapshot->windows->one({name => 'editor'})\n                    ->panes->where({width => {-gte => 1}})\n                    ->grep(sub ($pane) { $pane->height >= 1 });\n                my $selected = $panes->one({active => true});\n                die 'unexpected pane membership' unless $panes->count == 2;\n                my $name = $selected->window->name;\n                say $selected->id, ' is in window ', $name;\n            }\n            catch ($error) { $failure = $error }\n            $server->kill_session(session => $session);\n            die $failure if defined $failure;\n        }\n    );\n}\ncatch ($error) {\n    warn \"tmux quickstart failed: $error\\n\";\n    die $error;\n}\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/a1cab0324b600a5df6e34b92590b5c3bd8f79c69/examples/quickstart.pl"}]},"id":"LibTmux::Server","kind":"class","modifiers":[],"name":"Server","package":"LibTmux","product":"core","publicId":"LibTmux::Server","qualifiedName":"LibTmux::Server","signatures":[{"params":[],"raw":"package LibTmux::Server;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server"},{"apiScope":"exported","doc":{"body":"Return a fresh literal argument array for a caller-owned interactive terminal without I/O. The session target is a stable ID string; obtain it through :obj:`\"id\" in LibTmux::Session <LibTmux::Session::id>`. The caller owns terminal/process setup and exit observation; the bounded capture transport does not allocate a TTY. Invalid inputs throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>`.\n\n\n```perl\n    my $argv = $server->attach_argv(session => '$1');\n```","summary":"`attach_argv(session => session_id)`."},"id":"LibTmux::Server::attach_argv","kind":"method","modifiers":[],"name":"attach_argv","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::attach_argv","qualifiedName":"LibTmux::Server::attach_argv","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub attach_argv($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":978,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-attach_argv"},{"apiScope":"exported","doc":{"body":"Perform ordered independent literal requests and return a fresh array reference of {result, error} records in input order. Each result is :obj:`LibTmux::CommandResult <LibTmux::CommandResult>` or undef; each dispatch error is the original typed :obj:`LibTmux::X <LibTmux::X>` or undef. Nonzero command exits stay raw results. An empty input returns an empty array without command I/O. Requests are attempted in order, without rollback or tmux command-list attribution.\n\n\n```perl\n    my $results = $server->batch([['display-message', '-p', '#{version}']]);\n```","summary":"`batch(arrayref_of_argv)`."},"id":"LibTmux::Server::batch","kind":"method","modifiers":[],"name":"batch","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::batch","qualifiedName":"LibTmux::Server::batch","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"requests"}],"raw":"sub batch($self, $requests)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":974,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-batch"},{"apiScope":"exported","doc":{"body":"Read a :obj:`LibTmux::Pane <LibTmux::Pane>` and return raw terminal octets, including tmux's final newline. Optional start/end select native history rows; no UTF-8 replacement is performed. This I/O reads current observed content without waiting for application work. Command/transport failures propagate through :obj:`LibTmux::X <LibTmux::X>`.\n\n\n```perl\n    my $bytes = $server->capture_pane(pane => $pane, start => -20);\n```","summary":"`capture_pane(pane => Pane|pane_id, start => integer?, end => integer?)`."},"id":"LibTmux::Server::capture_pane","kind":"method","modifiers":[],"name":"capture_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::capture_pane","qualifiedName":"LibTmux::Server::capture_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub capture_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1058,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-capture_pane"},{"apiScope":"exported","doc":{"body":"Acquire a graph and return its :obj:`LibTmux::ClientSelection <LibTmux::ClientSelection>`. A daemon without attached clients produces an empty selection. Membership is copied away from graph storage. Acquisition failures propagate through :obj:`LibTmux::X <LibTmux::X>`; :obj:`\"detach_client\" <LibTmux::Server::detach_client>` changes client state explicitly.\n\n\n```perl\n    my $clients = $server->clients;\n```","summary":"`clients()`."},"id":"LibTmux::Server::clients","kind":"method","modifiers":[],"name":"clients","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::clients","qualifiedName":"LibTmux::Server::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub clients($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1077,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-clients"},{"apiScope":"exported","doc":{"body":"Perform one checked literal tmux command and return :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`. No shell wrapper or implicit tmux command list is used. Nonzero exits throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>` or a more specific target/server error; transport failures propagate.\n\n\n```perl\n    my $result = $server->cmd('display-message', '-p', '#{version}');\n```","summary":"`cmd(@literal_arguments)`."},"id":"LibTmux::Server::cmd","kind":"method","modifiers":[],"name":"cmd","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::cmd","qualifiedName":"LibTmux::Server::cmd","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":20,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"argv","variadic":"positional"}],"raw":"sub cmd($self, @argv)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":968,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-cmd"},{"apiScope":"exported","doc":{"body":"Delete the named daemon buffer loaded through :obj:`\"set_buffer\" <LibTmux::Server::set_buffer>`. Other daemon buffers remain untouched; later :obj:`\"show_buffer\" <LibTmux::Server::show_buffer>` calls report absence as a command failure.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->delete_buffer(name => 'application');\n```","summary":"`delete_buffer(name => string)`."},"id":"LibTmux::Server::delete_buffer","kind":"method","modifiers":[],"name":"delete_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::delete_buffer","qualifiedName":"LibTmux::Server::delete_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub delete_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-delete_buffer"},{"apiScope":"exported","doc":{"body":"Request detachment of a captured :obj:`LibTmux::Client <LibTmux::Client>` or explicit native client name. Command acceptance can precede client-process exit; callers owning an attached process must observe its exit separately.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->detach_client(client => $client);\n```","summary":"`detach_client(client => Client|client_name)`."},"id":"LibTmux::Server::detach_client","kind":"method","modifiers":[],"name":"detach_client","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::detach_client","qualifiedName":"LibTmux::Server::detach_client","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub detach_client($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1079,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-detach_client"},{"apiScope":"exported","doc":{"body":"Perform one raw command and return :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, including nonzero exits. stdout and stderr remain separate octet strings. stdin is optional bytes; cancel_fh is borrowed and remains open. Transport failures throw typed :obj:`LibTmux::X <LibTmux::X>` with bounded partial output when available.\n\n\n```perl\n    my $result = $server->execute(argv => ['list-sessions']);\n```","summary":"`execute(argv => arrayref, stdin => bytes?, timeout => seconds?, cancel_fh => handle?)`."},"id":"LibTmux::Server::execute","kind":"method","modifiers":[],"name":"execute","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::execute","qualifiedName":"LibTmux::Server::execute","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":19}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub execute($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":987,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-execute"},{"apiScope":"exported","doc":{"body":"Validate criteria and return an inspectable :obj:`LibTmux::QueryPlan <LibTmux::QueryPlan>` without I/O or mutation. The plan records required fields/relations, source commands, residuals, and conditional daemon capability needs. Invalid criteria throw :obj:`\"InvalidFilter\" in LibTmux::X <LibTmux::X::InvalidFilter>`. Executing :obj:`\"query_panes\" <LibTmux::Server::query_panes>` discovers the connected generation and capabilities.\n\n\n```perl\n    my $plan = $server->explain_panes(where => {width => {-gte => 120}});\n```","summary":"`explain_panes(where => criteria|Filter, pushdown => policy?)`."},"id":"LibTmux::Server::explain_panes","kind":"method","modifiers":[],"name":"explain_panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::explain_panes","qualifiedName":"LibTmux::Server::explain_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub explain_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1006,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-explain_panes"},{"apiScope":"exported","doc":{"body":"Read a session/global variable and return its octets. The native quoted representation is parsed as data; no shell evaluates it. Literal backslashes, newlines and non-UTF-8 bytes remain distinct. Empty text and '0' remain values. Performs I/O without mutation; missing or explicitly unset variables throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`, and malformed output throws :obj:`\"Codec\" in LibTmux::X <LibTmux::X::Codec>`. Captured targets follow :obj:`\"set_environment\" <LibTmux::Server::set_environment>`'s generation checks.\n\n\n```perl\n    my $value = $server->get_environment(session => $session, name => 'BUILD');\n```","summary":"`get_environment(name => env_name, session => session_target?)`."},"id":"LibTmux::Server::get_environment","kind":"method","modifiers":[],"name":"get_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::get_environment","qualifiedName":"LibTmux::Server::get_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1104,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-get_environment"},{"apiScope":"exported","doc":{"body":"Read an option and return its octets, decoding tmux's quoted string values. Literal backslashes and non-UTF-8 bytes remain distinct on older daemons. Key, numeric and command options retain native printed syntax. Array values are joined with newlines in native index order; an empty array returns `''`. Empty text and '0' remain values. `inherited => true` requests tmux's `-A` behavior; otherwise only the selected local level is queried. Performs I/O without mutation. Native missing-option errors throw :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`; malformed output throws :obj:`\"Codec\" in LibTmux::X <LibTmux::X::Codec>`. A built-in option without a local override may produce empty output. See :obj:`\"set_option\" <LibTmux::Server::set_option>` and :obj:`\"unset_option\" <LibTmux::Server::unset_option>`.\n\n\n```perl\n    my $value = $server->get_option(scope => 'window', target => $window->id, name => '@build');\n```","summary":"`get_option(name => string, scope => scope, target => id?, global => boolean?, inherited => boolean?)`."},"id":"LibTmux::Server::get_option","kind":"method","modifiers":[],"name":"get_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::get_option","qualifiedName":"LibTmux::Server::get_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub get_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1087,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-get_option"},{"apiScope":"exported","doc":{"body":"Destroy the selected :obj:`LibTmux::Pane <LibTmux::Pane>`. Killing a window's final pane may destroy the physical window and its :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` associations. Previously captured records remain readable observations.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_pane(pane => $pane);\n```","summary":"`kill_pane(pane => Pane|pane_id)`."},"id":"LibTmux::Server::kill_pane","kind":"method","modifiers":[],"name":"kill_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_pane","qualifiedName":"LibTmux::Server::kill_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1062,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-kill_pane"},{"apiScope":"exported","doc":{"body":"Explicitly request destruction of the connected tmux daemon. This method can affect a borrowed server and must be called intentionally; wrapper destruction never calls it. Successful command acceptance alone does not prove every daemon/client process exited.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_server;\n```","summary":"`kill_server()`."},"id":"LibTmux::Server::kill_server","kind":"method","modifiers":[],"name":"kill_server","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_server","qualifiedName":"LibTmux::Server::kill_server","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_server($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1074,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-kill_server"},{"apiScope":"exported","doc":{"body":"Destroy the selected :obj:`LibTmux::Session <LibTmux::Session>` and its links. Windows linked elsewhere can survive. Captured data remains local; later mutations through stale generation handles are checked.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_session(session => $session);\n```","summary":"`kill_session(session => Session|session_id)`."},"id":"LibTmux::Server::kill_session","kind":"method","modifiers":[],"name":"kill_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_session","qualifiedName":"LibTmux::Server::kill_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1070,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-kill_session"},{"apiScope":"exported","doc":{"body":"Destroy the physical :obj:`LibTmux::Window <LibTmux::Window>` and every :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` referring to it. Use :obj:`\"unlink_window\" <LibTmux::Server::unlink_window>` when removing one association is the intended effect.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->kill_window(window => $window);\n```","summary":"`kill_window(window => Window|window_id)`."},"id":"LibTmux::Server::kill_window","kind":"method","modifiers":[],"name":"kill_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::kill_window","qualifiedName":"LibTmux::Server::kill_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub kill_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1066,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-kill_window"},{"apiScope":"exported","doc":{"body":"Add an association from a physical :obj:`LibTmux::Window <LibTmux::Window>` to a :obj:`LibTmux::Session <LibTmux::Session>`. index is optional; conflicts remain command failures. Existing associations are preserved. Inspect new :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` records through :obj:`\"snapshot\" <LibTmux::Server::snapshot>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->link_window(window => $window, session => $session, index => 4);\n```","summary":"`link_window(window => Window|window_id, session => Session|session_id, index => integer?)`."},"id":"LibTmux::Server::link_window","kind":"method","modifiers":[],"name":"link_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::link_window","qualifiedName":"LibTmux::Server::link_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub link_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1018,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-link_window"},{"apiScope":"exported","doc":{"body":"Perform acquisition and return a fresh unblessed array reference of contextual hash records in tmux order, preserving duplicate physical identities. kind is session, window, pane, or client. An attached-client listing can be empty. Records are detached values; :obj:`\"snapshot\" <LibTmux::Server::snapshot>` normalizes the graph. Acquisition/codec failures propagate through :obj:`LibTmux::X <LibTmux::X>`.\n\n\n```perl\n    my $rows = $server->listings('window');\n```","summary":"`listings(kind)`."},"id":"LibTmux::Server::listings","kind":"method","modifiers":[],"name":"listings","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::listings","qualifiedName":"LibTmux::Server::listings","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"kind"}],"raw":"sub listings($self, $kind)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":970,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-listings"},{"apiScope":"exported","doc":{"body":"Move one contextual :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` into the destination session/index. Other links of the physical window keep their own associations. Use :obj:`\"link_window\" <LibTmux::Server::link_window>` to add an association without moving one.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->move_window(link => $link, session => $session, index => 4);\n```","summary":"`move_window(link => WindowLink|session_id:index, session => Session|session_id, index => integer?)`."},"id":"LibTmux::Server::move_window","kind":"method","modifiers":[],"name":"move_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::move_window","qualifiedName":"LibTmux::Server::move_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub move_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1026,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-move_window"},{"apiScope":"exported","doc":{"body":"Return a new server wrapper without I/O. Select socket_name or socket_path, never both. Defaults are executable tmux, timeout 5 seconds, and an 8 MiB combined retained-output limit. env is copied; child processes clear ambient TMUX and TMUX_PANE. Invalid configuration throws :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>`.\n\n\n```perl\n    my $server = LibTmux::Server->new(socket_name => 'application');\n```","summary":"`new(executable => tmux, socket_name|socket_path => string, timeout => seconds, max_output => bytes, config_file => path, env => hashref)`."},"id":"LibTmux::Server::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new","qualifiedName":"LibTmux::Server::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-new"},{"apiScope":"exported","doc":{"body":"Create a detached session and return its captured :obj:`LibTmux::Session <LibTmux::Session>`. command is a literal argument vector; shell_command explicitly requests a shell and is mutually exclusive. Omitting both uses tmux's default command. cwd is path octets; environment supplies NAME/value pairs to the first process. Performs I/O. If creation succeeds but acquisition fails, :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` retains the known generation-scoped creation receipt and cause.\n\n\n```perl\n    my $session = $server->new_session(name => 'application', command => ['/bin/cat']);\n```","summary":"`new_session(name => string, command => arrayref?, shell_command => string?, width => integer?, height => integer?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::new_session","kind":"method","modifiers":[],"name":"new_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new_session","qualifiedName":"LibTmux::Server::new_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":989,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-new_session"},{"apiScope":"exported","doc":{"body":"Create a detached physical window in the selected session and return its captured :obj:`LibTmux::Window <LibTmux::Window>`. command, shell_command, cwd, and environment follow :obj:`\"new_session\" <LibTmux::Server::new_session>`. The new link uses tmux's next available index. Performs I/O; :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` preserves known effects if subsequent acquisition fails.\n\n\n```perl\n    my $window = $server->new_window(session => $session, name => 'logs', command => ['/bin/cat']);\n```","summary":"`new_window(session => Session|session_id, name => string?, command => arrayref?, shell_command => string?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::new_window","kind":"method","modifiers":[],"name":"new_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::new_window","qualifiedName":"LibTmux::Server::new_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":993,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-new_window"},{"apiScope":"exported","doc":{"body":"```perl\n    my $operation = $server->operation('snapshot');\n```","summary":"`operation($name, %arguments)` validates and copies arguments, returning one :obj:`LibTmux::Operation <LibTmux::Operation>` without I/O. The optional Future facade shares this preparation and parsing boundary. Use the named methods above for synchronous execution. Invalid arguments or criteria throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` or :obj:`\"InvalidFilter\" in LibTmux::X <LibTmux::X::InvalidFilter>` before submission."},"id":"LibTmux::Server::operation","kind":"method","modifiers":[],"name":"operation","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::operation","qualifiedName":"LibTmux::Server::operation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21},{"end":33,"kind":"parameter","parameter":1,"start":28}],"params":[{"name":"name"},{"name":"args","variadic":"keyword"}],"raw":"sub operation($self, $name, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":854,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-operation"},{"apiScope":"exported","doc":{"body":"Acquire and return a new :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>` in captured physical-pane order. where accepts a hash reference or :obj:`LibTmux::Filter <LibTmux::Filter>`. auto verifies safe scalar candidates after complete local evaluation; never disables the native comparison. The default auto costs one extra command and supervisor when lowering is available; it does not reduce acquisition. Select never when only the captured answer is needed. require throws :obj:`\"Unsupported\" in LibTmux::X <LibTmux::X::Unsupported>` unless lowering is exact, or :obj:`\"QueryMismatch\" in LibTmux::X <LibTmux::X::QueryMismatch>` on disagreement. native_filter is an exclusive expert escape hatch. Empty successful matches remain a typed selection; acquisition/evaluation failures propagate.\n\n`on_verification` receives one detached report hashref in void context after a successful decision, including auto fallback. It runs inline once; its return is ignored and exceptions propagate unchanged unless the operation has already been cancelled. Cancellation suppresses subsequent result/error delivery. Failed queries do not invoke it. Report edits cannot change the returned selection. See :obj:`\"VERIFICATION REPORT\" <LibTmux::Server#VERIFICATION%20REPORT>` and :obj:`\"explain_panes\" <LibTmux::Server::explain_panes>`.\n\n\n```perl\n    my $panes = $server->query_panes(where => {active => true}, pushdown => 'auto');\n```","summary":"`query_panes(where => criteria|Filter?, pushdown => auto|never|require?, native_filter => string?, on_verification => coderef?)`."},"id":"LibTmux::Server::query_panes","kind":"method","modifiers":[],"name":"query_panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::query_panes","qualifiedName":"LibTmux::Server::query_panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub query_panes($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1002,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-query_panes"},{"apiScope":"exported","doc":{"body":"Rename the selected :obj:`LibTmux::Session <LibTmux::Session>` using a literal name. Existing captured handles keep the old observed name; use :obj:`\"snapshot\" <LibTmux::Server::snapshot>` to observe the change.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->rename_session(session => $session, name => 'application');\n```","summary":"`rename_session(session => Session|session_id, name => string)`."},"id":"LibTmux::Server::rename_session","kind":"method","modifiers":[],"name":"rename_session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::rename_session","qualifiedName":"LibTmux::Server::rename_session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":18,"kind":"name","start":4},{"end":31,"kind":"parameter","parameter":0,"start":26}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_session($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1010,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-rename_session"},{"apiScope":"exported","doc":{"body":"Rename the physical :obj:`LibTmux::Window <LibTmux::Window>` across all its links. Names remain literal rather than expanding tmux formats. Captured handles keep their observed name.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->rename_window(window => $window, name => 'logs');\n```","summary":"`rename_window(window => Window|window_id, name => string)`."},"id":"LibTmux::Server::rename_window","kind":"method","modifiers":[],"name":"rename_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::rename_window","qualifiedName":"LibTmux::Server::rename_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub rename_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1014,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-rename_window"},{"apiScope":"exported","doc":{"body":"Resize a :obj:`LibTmux::Pane <LibTmux::Pane>` to the supplied positive width and/or height. tmux's layout constraints may affect the resulting dimensions; inspect another :obj:`LibTmux::Snapshot <LibTmux::Snapshot>` for observed values.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->resize_pane(pane => $pane, width => 100);\n```","summary":"`resize_pane(pane => Pane|pane_id, width => positive_integer?, height => positive_integer?)`."},"id":"LibTmux::Server::resize_pane","kind":"method","modifiers":[],"name":"resize_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::resize_pane","qualifiedName":"LibTmux::Server::resize_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub resize_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1042,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-resize_pane"},{"apiScope":"exported","doc":{"body":"Apply an unambiguous predefined layout name or a checksum-prefixed native layout to a :obj:`LibTmux::Window <LibTmux::Window>`. Unknown or ambiguous predefined names throw :obj:`\"InvalidArgument\" in LibTmux::X <LibTmux::X::InvalidArgument>` before dispatch, including on tmux 3.3a. Native custom-layout validation remains tmux's responsibility.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_layout(window => $window, layout => 'tiled');\n```","summary":"`select_layout(window => Window|window_id, layout => string)`."},"id":"LibTmux::Server::select_layout","kind":"method","modifiers":[],"name":"select_layout","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_layout","qualifiedName":"LibTmux::Server::select_layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_layout($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1038,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-select_layout"},{"apiScope":"exported","doc":{"body":"Change the active :obj:`LibTmux::Pane <LibTmux::Pane>` of its physical window. This differs from selecting a session's :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_pane(pane => $pane);\n```","summary":"`select_pane(pane => Pane|pane_id)`."},"id":"LibTmux::Server::select_pane","kind":"method","modifiers":[],"name":"select_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_pane","qualifiedName":"LibTmux::Server::select_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1034,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-select_pane"},{"apiScope":"exported","doc":{"body":"Select a :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` within its session. A physical window alone cannot identify session-relative active state. Capture again through :obj:`\"snapshot\" <LibTmux::Server::snapshot>` to observe the selected link.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->select_window(link => $link);\n```","summary":"`select_window(link => WindowLink|session_id:index)`."},"id":"LibTmux::Server::select_window","kind":"method","modifiers":[],"name":"select_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::select_window","qualifiedName":"LibTmux::Server::select_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub select_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1030,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-select_window"},{"apiScope":"exported","doc":{"body":"Send the array's named keys in order to a :obj:`LibTmux::Pane <LibTmux::Pane>`. tmux interprets key names; arguments beginning with a dash remain key operands. An empty array sends no keys. Acceptance does not prove the pane application consumed input. Use :obj:`\"send_text\" <LibTmux::Server::send_text>` for literal text.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->send_keys(pane => $pane, keys => ['Enter']);\n```","summary":"`send_keys(pane => Pane|pane_id, keys => arrayref)`."},"id":"LibTmux::Server::send_keys","kind":"method","modifiers":[],"name":"send_keys","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::send_keys","qualifiedName":"LibTmux::Server::send_keys","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_keys($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1050,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-send_keys"},{"apiScope":"exported","doc":{"body":"Send literal text/bytes to a :obj:`LibTmux::Pane <LibTmux::Pane>`, then optionally send Enter. Empty text is permitted. Acceptance does not prove application completion. Use an application-specific observable handshake before relying on output; :obj:`\"capture_pane\" <LibTmux::Server::capture_pane>` reads observed terminal content.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->send_text(pane => $pane, text => 'hello', enter => true);\n```","summary":"`send_text(pane => Pane|pane_id, text => string|bytes, enter => boolean?)`."},"id":"LibTmux::Server::send_text","kind":"method","modifiers":[],"name":"send_text","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::send_text","qualifiedName":"LibTmux::Server::send_text","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub send_text($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1054,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-send_text"},{"apiScope":"exported","doc":{"body":"Load a named tmux buffer through stdin bytes rather than interpolating data into a command. Empty data is permitted. :obj:`\"show_buffer\" <LibTmux::Server::show_buffer>` retrieves bytes; buffer ownership remains in the daemon until :obj:`\"delete_buffer\" <LibTmux::Server::delete_buffer>` or an external change.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_buffer(name => 'application', data => \"a\\0b\");\n```","summary":"`set_buffer(name => string, data => bytes)`."},"id":"LibTmux::Server::set_buffer","kind":"method","modifiers":[],"name":"set_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_buffer","qualifiedName":"LibTmux::Server::set_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1112,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-set_buffer"},{"apiScope":"exported","doc":{"body":"Set a literal environment value for a :obj:`LibTmux::Session <LibTmux::Session>` handle or explicit session ID, or globally when session is omitted. Empty text and '0' remain values. Existing pane processes are unaffected; creation-time environment belongs to :obj:`\"new_session\" <LibTmux::Server::new_session>`, :obj:`\"new_window\" <LibTmux::Server::new_window>`, and :obj:`\"split_pane\" <LibTmux::Server::split_pane>`. Captured handles are checked against the connected daemon generation before dispatch; stale handles throw :obj:`\"StaleReference\" in LibTmux::X <LibTmux::X::StaleReference>`. Raw IDs target the current session. The probe and mutation remain separate operations.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_environment(session => $session, name => 'BUILD', value => '0');\n```","summary":"`set_environment(name => env_name, value => bytes, session => session_target?)`."},"id":"LibTmux::Server::set_environment","kind":"method","modifiers":[],"name":"set_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_environment","qualifiedName":"LibTmux::Server::set_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":19,"kind":"name","start":4},{"end":32,"kind":"parameter","parameter":0,"start":27}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1100,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-set_environment"},{"apiScope":"exported","doc":{"body":"Set a native hook or sparse hook[index] entry for an explicit session target or global scope. command is deliberately a tmux command string, unlike literal process argv. :obj:`\"show_hooks\" <LibTmux::Server::show_hooks>` preserves native indexes/quoting rather than inventing a flattened hook list.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_hook(target => $session->id, name => 'after-select-window[3]', command => 'display-message hook');\n```","summary":"`set_hook(name => hook_or_hook[index], command => explicit_tmux_command_string, target => session_id?, global => boolean?)`."},"id":"LibTmux::Server::set_hook","kind":"method","modifiers":[],"name":"set_hook","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_hook","qualifiedName":"LibTmux::Server::set_hook","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_hook($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1094,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-set_hook"},{"apiScope":"exported","doc":{"body":"Set an option at explicit session/window/pane/server scope. Supply an exact target ID for local settings or global => true for the global level. Empty and zero values are preserved. :obj:`\"get_option\" <LibTmux::Server::get_option>` controls whether inherited values participate.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_option(scope => 'window', target => $window->id, name => '@build', value => '0');\n```","summary":"`set_option(name => string, value => string|integer, scope => session|window|pane|server, target => id?, global => boolean?)`."},"id":"LibTmux::Server::set_option","kind":"method","modifiers":[],"name":"set_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_option","qualifiedName":"LibTmux::Server::set_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1083,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-set_option"},{"apiScope":"exported","doc":{"body":"Set a :obj:`LibTmux::Pane <LibTmux::Pane>` title. Literal input is protected from format expansion; tmux's own title sanitization remains observable in a new :obj:`LibTmux::Snapshot <LibTmux::Snapshot>`.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->set_title(pane => $pane, title => 'build.v2');\n```","summary":"`set_title(pane => Pane|pane_id, title => string)`."},"id":"LibTmux::Server::set_title","kind":"method","modifiers":[],"name":"set_title","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::set_title","qualifiedName":"LibTmux::Server::set_title","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":21}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub set_title($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1046,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-set_title"},{"apiScope":"exported","doc":{"body":"Read a named tmux buffer and return raw octets, including embedded NUL bytes. Empty data remains an empty string. Performs I/O; a missing buffer throws :obj:`\"Command\" in LibTmux::X <LibTmux::X::Command>`. See :obj:`\"set_buffer\" <LibTmux::Server::set_buffer>`.\n\n\n```perl\n    my $bytes = $server->show_buffer(name => 'application');\n```","summary":"`show_buffer(name => string)`."},"id":"LibTmux::Server::show_buffer","kind":"method","modifiers":[],"name":"show_buffer","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::show_buffer","qualifiedName":"LibTmux::Server::show_buffer","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":23}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_buffer($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1116,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-show_buffer"},{"apiScope":"exported","doc":{"body":"Read hooks and return raw octets preserving sparse indexes and tmux quoting. No hooks produce empty text. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. See :obj:`\"set_hook\" <LibTmux::Server::set_hook>` for explicit command-string semantics.\n\n\n```perl\n    my $hooks = $server->show_hooks(target => $session->id);\n```","summary":"`show_hooks(target => session_id?, global => boolean?)`."},"id":"LibTmux::Server::show_hooks","kind":"method","modifiers":[],"name":"show_hooks","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::show_hooks","qualifiedName":"LibTmux::Server::show_hooks","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub show_hooks($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1096,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-show_hooks"},{"apiScope":"exported","doc":{"body":"Perform strict graph acquisition and return :obj:`LibTmux::Snapshot <LibTmux::Snapshot>`. Physical windows/panes appear once; :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` retains each contextual association. Capture start/end describe an observation interval, not an atomic transaction. Acquisition, unsupported capabilities, and incomplete topology throw typed :obj:`LibTmux::X <LibTmux::X>`; no partial snapshot is returned.\n\n\n```perl\n    my $snapshot = $server->snapshot;\n```","summary":"`snapshot()`."},"id":"LibTmux::Server::snapshot","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::snapshot","qualifiedName":"LibTmux::Server::snapshot","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":20}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub snapshot($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1000,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-snapshot"},{"apiScope":"exported","doc":{"body":"Split the targeted pane and return the new captured :obj:`LibTmux::Pane <LibTmux::Pane>`. horizontal selects side-by-side placement; false uses tmux's vertical split. command, shell_command, cwd, and environment follow :obj:`\"new_session\" <LibTmux::Server::new_session>`. Performs I/O; creation/acquisition failures follow :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>`.\n\n\n```perl\n    my $other = $server->split_pane(pane => $pane, horizontal => true, command => ['/bin/cat']);\n```","summary":"`split_pane(pane => Pane|pane_id, horizontal => boolean?, command => arrayref?, cwd => bytes?, environment => hashref?)`."},"id":"LibTmux::Server::split_pane","kind":"method","modifiers":[],"name":"split_pane","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::split_pane","qualifiedName":"LibTmux::Server::split_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub split_pane($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":997,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-split_pane"},{"apiScope":"exported","doc":{"body":"Remove exactly one :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, given a captured link or session_id:index string. Removing the final link can destroy its physical window; other linked associations retain their context.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unlink_window(link => $link);\n```","summary":"`unlink_window(link => WindowLink|session_id:index)`."},"id":"LibTmux::Server::unlink_window","kind":"method","modifiers":[],"name":"unlink_window","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unlink_window","qualifiedName":"LibTmux::Server::unlink_window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unlink_window($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1022,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-unlink_window"},{"apiScope":"exported","doc":{"body":"Unset the named session/global variable. This differs from setting an empty value; :obj:`\"get_environment\" <LibTmux::Server::get_environment>` reports the unset state as a command error.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unset_environment(session => $session, name => 'BUILD');\n```","summary":"`unset_environment(name => env_name, session => session_target?)`."},"id":"LibTmux::Server::unset_environment","kind":"method","modifiers":[],"name":"unset_environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unset_environment","qualifiedName":"LibTmux::Server::unset_environment","signatures":[{"methodKind":"call","nativeSyntax":[{"end":21,"kind":"name","start":4},{"end":34,"kind":"parameter","parameter":0,"start":29}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_environment($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1108,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-unset_environment"},{"apiScope":"exported","doc":{"body":"Remove the selected local/global option so inheritance can take effect. Scope and target follow :obj:`\"set_option\" <LibTmux::Server::set_option>`; removing an override differs from assigning empty text.\n\nReturns `undef` after command acceptance. Performs I/O; failures propagate through :obj:`LibTmux::X <LibTmux::X>`. Captured objects are not modified.\n\n\n```perl\n    $server->unset_option(scope => 'window', target => $window->id, name => '@build');\n```","summary":"`unset_option(name => string, scope => scope, target => id?, global => boolean?)`."},"id":"LibTmux::Server::unset_option","kind":"method","modifiers":[],"name":"unset_option","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server::unset_option","qualifiedName":"LibTmux::Server::unset_option","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":29,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub unset_option($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Server.pm","line":1091,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-server-unset_option"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured session entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Session","kind":"class","modifiers":[],"name":"Session","package":"LibTmux","product":"core","publicId":"LibTmux::Session","qualifiedName":"LibTmux::Session","signatures":[{"params":[],"raw":"package LibTmux::Session;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Session::attached","kind":"method","modifiers":[],"name":"attached","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::attached","qualifiedName":"LibTmux::Session::attached","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub attached($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-attached"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Session::created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::created","qualifiedName":"LibTmux::Session::created","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub created($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-created"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Session::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::generation","qualifiedName":"LibTmux::Session::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-generation"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Session::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::id","qualifiedName":"LibTmux::Session::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Session::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::identity","qualifiedName":"LibTmux::Session::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Session::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::kind","qualifiedName":"LibTmux::Session::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Session::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::name","qualifiedName":"LibTmux::Session::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-name"},{"apiScope":"exported","doc":{"summary":"bytes. Local captured data; no I/O."},"id":"LibTmux::Session::path","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::path","qualifiedName":"LibTmux::Session::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-path"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Session::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::server_id","qualifiedName":"LibTmux::Session::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Session::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::to_record","qualifiedName":"LibTmux::Session::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-to_record"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` entities. Local captured data; no I/O."},"id":"LibTmux::Session::window_links","kind":"method","modifiers":[],"name":"window_links","package":"LibTmux","parent":"LibTmux::Session","product":"core","publicId":"LibTmux::Session::window_links","qualifiedName":"LibTmux::Session::window_links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub window_links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Session.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-session-window_links"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Session <LibTmux::Session>` handles from one server generation. Empty instances still validate against the session schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured session entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::SessionSelection","kind":"class","modifiers":[],"name":"SessionSelection","package":"LibTmux","product":"core","publicId":"LibTmux::SessionSelection","qualifiedName":"LibTmux::SessionSelection","signatures":[{"params":[],"raw":"package LibTmux::SessionSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/SessionSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::SessionSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::count","qualifiedName":"LibTmux::SessionSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::SessionSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::exists","qualifiedName":"LibTmux::SessionSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::SessionSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::first","qualifiedName":"LibTmux::SessionSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::SessionSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::grep","qualifiedName":"LibTmux::SessionSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::SessionSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::iterator","qualifiedName":"LibTmux::SessionSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::SessionSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::new","qualifiedName":"LibTmux::SessionSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::SessionSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::one","qualifiedName":"LibTmux::SessionSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::SessionSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::one_or_undef","qualifiedName":"LibTmux::SessionSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::SessionSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::to_array","qualifiedName":"LibTmux::SessionSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::SessionSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::SessionSelection","product":"core","publicId":"LibTmux::SessionSelection::where","qualifiedName":"LibTmux::SessionSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-sessionselection-where"},{"apiScope":"exported","doc":{"body":"\n## EXECUTION\n\nAll methods in this module operate on local captured data and perform no tmux I/O. Ordering is deterministic; public query methods do not mutate membership. Typed validation/evaluation errors propagate. See :obj:`\"snapshot\" in LibTmux::Server <LibTmux::Server::snapshot>` for explicit acquisition and :obj:`LibTmux::X <LibTmux::X>` for machine-readable failures.\n\n","summary":"Captured graph with explicit completeness"},"id":"LibTmux::Snapshot","kind":"class","modifiers":[],"name":"Snapshot","package":"LibTmux","product":"core","publicId":"LibTmux::Snapshot","qualifiedName":"LibTmux::Snapshot","signatures":[{"params":[],"raw":"package LibTmux::Snapshot;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::ClientSelection <LibTmux::ClientSelection>` in captured order. A loaded empty client set is valid."},"id":"LibTmux::Snapshot::clients","kind":"method","modifiers":[],"name":"clients","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::clients","qualifiedName":"LibTmux::Snapshot::clients","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub clients($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":209,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-clients"},{"apiScope":"exported","doc":{"summary":"Return the capture completeness Boolean. The strict live acquisition path fails on incomplete topology; it does not synthesize empty relations."},"id":"LibTmux::Snapshot::complete","kind":"method","modifiers":[],"name":"complete","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::complete","qualifiedName":"LibTmux::Snapshot::complete","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub complete($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":104,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-complete"},{"apiScope":"exported","doc":{"summary":"`from_records(server_id => ..., generation => ..., sessions => [...], windows => [...], window_links => [...], panes => [...], clients => [...])` constructs a detached graph. Scalar records and relation IDs are copied. Omitted fields/collections remain unloaded; null is explicit. Invalid identities or inconsistent complete topology throw typed acquisition errors."},"id":"LibTmux::Snapshot::from_records","kind":"method","modifiers":[],"name":"from_records","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::from_records","qualifiedName":"LibTmux::Snapshot::from_records","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":30,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub from_records($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-from_records"},{"apiScope":"exported","doc":{"summary":"Return the captured daemon generation. :obj:`LibTmux::Server <LibTmux::Server>` checks it before mutations through captured handles; retained snapshots never silently refresh."},"id":"LibTmux::Snapshot::generation","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::generation","qualifiedName":"LibTmux::Snapshot::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":103,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-generation"},{"apiScope":"exported","doc":{"summary":"Return a fresh metadata hash with capture start/end, daemon version, and PID where acquired. Several commands observe an interval; the snapshot is not an atomic tmux transaction."},"id":"LibTmux::Snapshot::metadata","kind":"method","modifiers":[],"name":"metadata","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::metadata","qualifiedName":"LibTmux::Snapshot::metadata","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub metadata($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":105,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-metadata"},{"apiScope":"exported","doc":{"summary":"`pane_by_id('%3')` returns a :obj:`LibTmux::Pane <LibTmux::Pane>` or undef. The returned handle retains the captured graph after this wrapper goes out of scope."},"id":"LibTmux::Snapshot::pane_by_id","kind":"method","modifiers":[],"name":"pane_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::pane_by_id","qualifiedName":"LibTmux::Snapshot::pane_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"id"}],"raw":"sub pane_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":212,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-pane_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>` containing each physical pane identity once. Membership edits cannot change the graph store."},"id":"LibTmux::Snapshot::panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::panes","qualifiedName":"LibTmux::Snapshot::panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub panes($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":208,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-panes"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. Entity IDs are meaningful only within this scope and :obj:`\"generation\" <LibTmux::Snapshot::generation>`."},"id":"LibTmux::Snapshot::server_id","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::server_id","qualifiedName":"LibTmux::Snapshot::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":102,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-server_id"},{"apiScope":"exported","doc":{"summary":"`session_by_id('$1')` returns a :obj:`LibTmux::Session <LibTmux::Session>` or undef. Single quotes preserve the dollar-prefixed ID instead of interpolating a regex capture."},"id":"LibTmux::Snapshot::session_by_id","kind":"method","modifiers":[],"name":"session_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::session_by_id","qualifiedName":"LibTmux::Snapshot::session_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":17,"kind":"name","start":4},{"end":28,"kind":"parameter","parameter":0,"start":25}],"params":[{"name":"id"}],"raw":"sub session_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":210,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-session_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::SessionSelection <LibTmux::SessionSelection>` in captured order. Empty loaded collections yield empty selections; unloaded collections throw."},"id":"LibTmux::Snapshot::sessions","kind":"method","modifiers":[],"name":"sessions","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::sessions","qualifiedName":"LibTmux::Snapshot::sessions","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub sessions($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":205,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-sessions"},{"apiScope":"exported","doc":{"summary":"Return independent scalar records and adjacency IDs for detached use. No handles or live transport are serialized."},"id":"LibTmux::Snapshot::to_records","kind":"method","modifiers":[],"name":"to_records","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::to_records","qualifiedName":"LibTmux::Snapshot::to_records","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub to_records($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":214,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-to_records"},{"apiScope":"exported","doc":{"summary":"`window_by_id('@3')` returns one physical :obj:`LibTmux::Window <LibTmux::Window>` or undef, independent of session link context."},"id":"LibTmux::Snapshot::window_by_id","kind":"method","modifiers":[],"name":"window_by_id","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::window_by_id","qualifiedName":"LibTmux::Snapshot::window_by_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"id"}],"raw":"sub window_by_id($self, $id)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":211,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-window_by_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::WindowLinkSelection <LibTmux::WindowLinkSelection>` retaining every session/index association, including repeated links of one physical window."},"id":"LibTmux::Snapshot::window_links","kind":"method","modifiers":[],"name":"window_links","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::window_links","qualifiedName":"LibTmux::Snapshot::window_links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4}],"params":[],"raw":"sub window_links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":207,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-window_links"},{"apiScope":"exported","doc":{"summary":"Return a fresh :obj:`LibTmux::WindowSelection <LibTmux::WindowSelection>` containing each physical window identity once. Context lives in :obj:`\"window_links\" <LibTmux::Snapshot::window_links>`."},"id":"LibTmux::Snapshot::windows","kind":"method","modifiers":[],"name":"windows","package":"LibTmux","parent":"LibTmux::Snapshot","product":"core","publicId":"LibTmux::Snapshot::windows","qualifiedName":"LibTmux::Snapshot::windows","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub windows($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Snapshot.pm","line":206,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-snapshot-windows"},{"apiScope":"exported","doc":{"body":"\n## RESULTS\n\n:obj:`LibTmux::CommandResult <LibTmux::CommandResult>` exposes stdout, stderr, exit_code, signal, raw_status, and success. Output remains octets.\n\nThe private supervisor owns program signals/groups and reaps the program. It receives CHLD, INT and TERM through a Linux signal descriptor, so child exit cannot wait for a deferred Perl handler. This mask belongs only to the supervisor; the command restores its inherited mask before execution. Application SIGCHLD handlers remain intact; SIGCHLD=IGNORE is refused. Cancellation handles are borrowed and remain open. Cancellation after release can have effects and never implies rollback. Parent death triggers cleanup.\n\nOwned supervisor and command branches close unrelated inherited descriptors through Linux `/proc/self/fd`, preserving the caller's handles. Native descriptors without close-on-exec cannot leak into a newly started tmux daemon. Only standard streams and each branch's required protocol/cancellation pipes remain open. Enumeration or closure failures prevent execution and throw :obj:`\"Transport\" in LibTmux::X <LibTmux::X::Transport>` or :obj:`\"Spawn\" in LibTmux::X <LibTmux::X::Spawn>`. No arbitrary descriptor-passing API is selected. Forking hosts with native threads remains unqualified.\n\n","summary":"Supervised literal process execution"},"id":"LibTmux::Transport","kind":"class","modifiers":[],"name":"Transport","package":"LibTmux","product":"core","publicId":"LibTmux::Transport","qualifiedName":"LibTmux::Transport","signatures":[{"params":[],"raw":"package LibTmux::Transport;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Transport.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-transport"},{"apiScope":"exported","doc":{"summary":"`run(argv => [...], stdin => $octets, timeout => $seconds, max_output => $bytes, cancel_fh => $handle)` returns a :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`. Stdout/stderr are separate octet strings. Nonzero exits are results; spawn, timeout, cancellation, output limits, and supervision failures throw :obj:`LibTmux::X <LibTmux::X>` exceptions. `timeout` bounds one command's execution loop, excluding supervisor setup, async queue waiting, and separate cleanup time."},"id":"LibTmux::Transport::run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::run","qualifiedName":"LibTmux::Transport::run","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub run($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Transport.pm","line":100,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-transport-run"},{"apiScope":"exported","doc":{"summary":"Return a :obj:`LibTmux::ProcessJob <LibTmux::ProcessJob>` for an executor adapter."},"id":"LibTmux::Transport::start","kind":"method","modifiers":[],"name":"start","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::start","qualifiedName":"LibTmux::Transport::start","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":23,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub start($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Transport.pm","line":96,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-transport-start"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured window entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::Window","kind":"class","modifiers":[],"name":"Window","package":"LibTmux","product":"core","publicId":"LibTmux::Window","qualifiedName":"LibTmux::Window","signatures":[{"params":[],"raw":"package LibTmux::Window;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Pane <LibTmux::Pane>` entity or undef. Local captured data; no I/O."},"id":"LibTmux::Window::active_pane","kind":"method","modifiers":[],"name":"active_pane","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::active_pane","qualifiedName":"LibTmux::Window::active_pane","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub active_pane($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-active_pane"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::Window::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::generation","qualifiedName":"LibTmux::Window::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-generation"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Window::height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::height","qualifiedName":"LibTmux::Window::height","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub height($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-height"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::id","qualifiedName":"LibTmux::Window::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::Window::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::identity","qualifiedName":"LibTmux::Window::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-identity"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::Window::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::kind","qualifiedName":"LibTmux::Window::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-kind"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::layout","kind":"method","modifiers":[],"name":"layout","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::layout","qualifiedName":"LibTmux::Window::layout","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub layout($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-layout"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` entities. Local captured data; no I/O."},"id":"LibTmux::Window::links","kind":"method","modifiers":[],"name":"links","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::links","qualifiedName":"LibTmux::Window::links","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub links($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-links"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::Window::name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::name","qualifiedName":"LibTmux::Window::name","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub name($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-name"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Selection <LibTmux::Selection>` of :obj:`LibTmux::Pane <LibTmux::Pane>` entities. Local captured data; no I/O."},"id":"LibTmux::Window::panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::panes","qualifiedName":"LibTmux::Window::panes","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub panes($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-panes"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::Window::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::server_id","qualifiedName":"LibTmux::Window::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-server_id"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::Window::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::to_record","qualifiedName":"LibTmux::Window::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-to_record"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::Window::width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Window","product":"core","publicId":"LibTmux::Window::width","qualifiedName":"LibTmux::Window::width","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub width($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Window.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-window-width"},{"apiScope":"exported","doc":{"body":"\n## OWNERSHIP\n\nReaders use the retained graph and never refresh it. Acquire a new snapshot for new state. Inherited :obj:`to_record <LibTmux::Entity::to_record>` exports a detached scalar record.\n\n","summary":"Captured window_link entity"},"extends":["LibTmux::Entity"],"id":"LibTmux::WindowLink","kind":"class","modifiers":[],"name":"WindowLink","package":"LibTmux","product":"core","publicId":"LibTmux::WindowLink","qualifiedName":"LibTmux::WindowLink","signatures":[{"params":[],"raw":"package LibTmux::WindowLink;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink"},{"apiScope":"exported","doc":{"summary":"boolean. Local captured data; no I/O."},"id":"LibTmux::WindowLink::active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::active","qualifiedName":"LibTmux::WindowLink::active","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub active($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":5,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-active"},{"apiScope":"exported","doc":{"summary":"Return the captured generation. Restarted daemons cannot silently reuse this handle."},"id":"LibTmux::WindowLink::generation","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"generation","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::generation","qualifiedName":"LibTmux::WindowLink::generation","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub generation($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-generation"},{"apiScope":"exported","doc":{"summary":"string. Local captured data; no I/O."},"id":"LibTmux::WindowLink::id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::id","qualifiedName":"LibTmux::WindowLink::id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":6,"kind":"name","start":4}],"params":[],"raw":"sub id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":6,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-id"},{"apiScope":"exported","doc":{"summary":"Return an opaque identity key scoped by server, generation, kind, and string ID. It is suitable for local equality; duplicate selection occurrences remain separate occurrences."},"id":"LibTmux::WindowLink::identity","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"identity","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::identity","qualifiedName":"LibTmux::WindowLink::identity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub identity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-identity"},{"apiScope":"exported","doc":{"summary":"integer. Local captured data; no I/O."},"id":"LibTmux::WindowLink::index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::index","qualifiedName":"LibTmux::WindowLink::index","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub index($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-index"},{"apiScope":"exported","doc":{"summary":"Return the schema entity-kind string. Concrete public field readers belong to :obj:`LibTmux::Pane <LibTmux::Pane>`, :obj:`LibTmux::Window <LibTmux::Window>`, :obj:`LibTmux::WindowLink <LibTmux::WindowLink>`, :obj:`LibTmux::Session <LibTmux::Session>`, and :obj:`LibTmux::Client <LibTmux::Client>`."},"id":"LibTmux::WindowLink::kind","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::kind","qualifiedName":"LibTmux::WindowLink::kind","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub kind($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-kind"},{"apiScope":"exported","doc":{"summary":"Return the captured server scope. No daemon discovery or refresh occurs."},"id":"LibTmux::WindowLink::server_id","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"server_id","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::server_id","qualifiedName":"LibTmux::WindowLink::server_id","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub server_id($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-server_id"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Session <LibTmux::Session>` entity. Local captured data; no I/O."},"id":"LibTmux::WindowLink::session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::session","qualifiedName":"LibTmux::WindowLink::session","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub session($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-session"},{"apiScope":"exported","doc":{"summary":"Return a fresh hash reference of captured scalar fields and adjacency IDs. Editing it does not change the retained graph. Retaining the entity retains its captured graph, with no transport ownership or reference cycle."},"id":"LibTmux::WindowLink::to_record","inheritedFrom":"LibTmux::Entity","kind":"method","modifiers":[],"name":"to_record","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::to_record","qualifiedName":"LibTmux::WindowLink::to_record","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4}],"params":[],"raw":"sub to_record($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Entity.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-to_record"},{"apiScope":"exported","doc":{"summary":":obj:`LibTmux::Window <LibTmux::Window>` entity. Local captured data; no I/O."},"id":"LibTmux::WindowLink::window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::WindowLink","product":"core","publicId":"LibTmux::WindowLink::window","qualifiedName":"LibTmux::WindowLink::window","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub window($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLink.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlink-window"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::WindowLink <LibTmux::WindowLink>` handles from one server generation. Empty instances still validate against the window_link schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured window_link entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::WindowLinkSelection","kind":"class","modifiers":[],"name":"WindowLinkSelection","package":"LibTmux","product":"core","publicId":"LibTmux::WindowLinkSelection","qualifiedName":"LibTmux::WindowLinkSelection","signatures":[{"params":[],"raw":"package LibTmux::WindowLinkSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowLinkSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::WindowLinkSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::count","qualifiedName":"LibTmux::WindowLinkSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::WindowLinkSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::exists","qualifiedName":"LibTmux::WindowLinkSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::WindowLinkSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::first","qualifiedName":"LibTmux::WindowLinkSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::WindowLinkSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::grep","qualifiedName":"LibTmux::WindowLinkSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::WindowLinkSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::iterator","qualifiedName":"LibTmux::WindowLinkSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::WindowLinkSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::new","qualifiedName":"LibTmux::WindowLinkSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::WindowLinkSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::one","qualifiedName":"LibTmux::WindowLinkSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::WindowLinkSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::one_or_undef","qualifiedName":"LibTmux::WindowLinkSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::WindowLinkSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::to_array","qualifiedName":"LibTmux::WindowLinkSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::WindowLinkSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::WindowLinkSelection","product":"core","publicId":"LibTmux::WindowLinkSelection::where","qualifiedName":"LibTmux::WindowLinkSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowlinkselection-where"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nInherits the fixed-return local query API of :obj:`LibTmux::Selection <LibTmux::Selection>`. Members must be defined :obj:`LibTmux::Window <LibTmux::Window>` handles from one server generation. Empty instances still validate against the window schema. Native array edits are possible; query methods validate membership and never perform tmux I/O.\n\n","summary":"Native array selection of captured window entities"},"extends":["LibTmux::Selection"],"id":"LibTmux::WindowSelection","kind":"class","modifiers":[],"name":"WindowSelection","package":"LibTmux","product":"core","publicId":"LibTmux::WindowSelection","qualifiedName":"LibTmux::WindowSelection","signatures":[{"params":[],"raw":"package LibTmux::WindowSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/WindowSelection.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection"},{"apiScope":"exported","doc":{"summary":"`count($criteria?)` returns an integer. Empty input returns zero. Validate all members before evaluating the optional criterion; count every matching occurrence, including duplicates."},"id":"LibTmux::WindowSelection::count","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::count","qualifiedName":"LibTmux::WindowSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub count($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":77,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-count"},{"apiScope":"exported","doc":{"summary":"`exists($criteria?)` returns a native Boolean. Empty input returns false. After validating the entire membership, stop at the first matching entity. A reference itself remains true even when empty."},"id":"LibTmux::WindowSelection::exists","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"exists","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::exists","qualifiedName":"LibTmux::WindowSelection::exists","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub exists($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":85,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-exists"},{"apiScope":"exported","doc":{"summary":"`first($criteria?)` returns the first matching entity or undef. Input order determines first; after membership validation, later field reads may be skipped."},"id":"LibTmux::WindowSelection::first","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::first","qualifiedName":"LibTmux::WindowSelection::first","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub first($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":89,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-first"},{"apiScope":"exported","doc":{"summary":"`grep($callback)` returns a new same-class selection. Invoke the callback in scalar context with exactly one entity argument and a localized `$_`. Both bindings hold copies of the reference: assignment cannot replace a source slot. Restore `$_` and propagate the original thrown value even on failure. Predicates must not edit the traversed sequence."},"id":"LibTmux::WindowSelection::grep","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::grep","qualifiedName":"LibTmux::WindowSelection::grep","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":25,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"callback"}],"raw":"sub grep($self, $callback)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":54,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-grep"},{"apiScope":"exported","doc":{"summary":"Return a fresh local cursor with a copy of current membership. Its `next` returns an entity or undef only at exhaustion. Later native array edits do not alter this traversal; the selection remains replayable."},"id":"LibTmux::WindowSelection::iterator","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::iterator","qualifiedName":"LibTmux::WindowSelection::iterator","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub iterator($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":122,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-iterator"},{"apiScope":"exported","doc":{"body":"Members may come from separate captures of the same server generation; each retains its own observation. Mixing servers or daemon generations throws :obj:`\"InvalidSelection\" in LibTmux::X <LibTmux::X::InvalidSelection>`. Combining captures does not reconcile their times.","summary":"`new(@entities)` creates a concrete blessed array reference and validates every member. Construct an entity-specific selection such as :obj:`LibTmux::PaneSelection <LibTmux::PaneSelection>`; an empty instance retains that schema."},"id":"LibTmux::WindowSelection::new","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::new","qualifiedName":"LibTmux::WindowSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":22,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"items","variadic":"positional"}],"raw":"sub new($class, @items)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":7,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-new"},{"apiScope":"exported","doc":{"summary":"`one($criteria?)` returns one entity. Zero throws :obj:`NoMatch <LibTmux::X::NoMatch>`; a second occurrence throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`, reporting at least two and their IDs. Two occurrences of one identity are still ambiguous."},"id":"LibTmux::WindowSelection::one","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::one","qualifiedName":"LibTmux::WindowSelection::one","signatures":[{"methodKind":"call","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":15}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":119,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-one"},{"apiScope":"exported","doc":{"summary":"`one_or_undef($criteria?)` returns an entity or undef for absence. A second matching occurrence still throws :obj:`MultipleMatches <LibTmux::X::MultipleMatches>`."},"id":"LibTmux::WindowSelection::one_or_undef","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"one_or_undef","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::one_or_undef","qualifiedName":"LibTmux::WindowSelection::one_or_undef","signatures":[{"methodKind":"call","nativeSyntax":[{"end":16,"kind":"name","start":4},{"end":33,"kind":"parameter","parameter":0,"start":24}],"params":[{"name":"criteria","variadic":"positional"}],"raw":"sub one_or_undef($self, @criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":120,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-one_or_undef"},{"apiScope":"exported","doc":{"summary":"Return a fresh, unblessed array reference containing the same entity references. Editing its membership cannot corrupt graph adjacency or this selection. Captured entity values remain read-only through public readers."},"id":"LibTmux::WindowSelection::to_array","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"to_array","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::to_array","qualifiedName":"LibTmux::WindowSelection::to_array","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub to_array($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":66,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-to_array"},{"apiScope":"exported","doc":{"summary":"`where($criteria_or_filter)` eagerly returns a new selection of the same concrete class in scalar, list, or void context. Complete validation precedes evaluation, including on empty input. See :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`. Order and duplicate occurrences are preserved."},"id":"LibTmux::WindowSelection::where","inheritedFrom":"LibTmux::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::WindowSelection","product":"core","publicId":"LibTmux::WindowSelection::where","qualifiedName":"LibTmux::WindowSelection::where","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":17}],"params":[{"name":"criteria"}],"raw":"sub where($self, $criteria)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/Selection.pm","line":48,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-windowselection-where"},{"apiScope":"exported","doc":{"body":"\n## SYNOPSIS\n\n\n```perl\n    use LibTmux::Workspace;\n    my $workspace = LibTmux::Workspace->from_json($json_octets);\n    my $plan = $workspace->plan(existing => 'error');\n    my $report = $workspace->load(server => $server);\n```\n\n\n## COMMAND LINE\n\nThe packaged `libtmux-workspace` executable exposes `validate`, `plan`, and `load`. `--dry-run` selects planning without tmux I/O. See the installed executable's help for socket and repeat-application options.\n\n\n## DOCUMENTATION\n\nRead the [Perl documentation](https://libtmux.org/en/perl/) and [workspace guide](https://libtmux.org/en/perl/latest/workspace/source-guide/) for complete configuration and CLI examples. The [API reference](https://libtmux.org/en/perl/latest/workspace/reference/libtmux-workspace/) documents validation, planning, loading, and failure reports. The [CPAN distribution](https://metacpan.org/dist/LibTmux-Workspace) includes runnable consumer examples. The `0.x` API can change between releases.\n\n","summary":"Versioned JSON configuration and owned orchestration"},"id":"LibTmux::Workspace","kind":"class","modifiers":[],"name":"Workspace","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace","qualifiedName":"LibTmux::Workspace","signatures":[{"params":[],"raw":"package LibTmux::Workspace;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace"},{"apiScope":"exported","doc":{"body":"\n## EXCEPTIONS\n\n","summary":"Workspace configuration and partial-load failures"},"id":"LibTmux::Workspace::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X","qualifiedName":"LibTmux::Workspace::X","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x"},{"apiScope":"exported","doc":{"summary":"Invalid versioned configuration. `path` identifies the rejected input."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Config","kind":"exception","modifiers":[],"name":"Config","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Config","qualifiedName":"LibTmux::Workspace::X::Config","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Config;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Config::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::count","qualifiedName":"LibTmux::Workspace::X::Config::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Config::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::details","qualifiedName":"LibTmux::Workspace::X::Config::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Config::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::dispatched","qualifiedName":"LibTmux::Workspace::X::Config::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Config::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::entity","qualifiedName":"LibTmux::Workspace::X::Config::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Config::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::expected","qualifiedName":"LibTmux::Workspace::X::Config::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Config::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::matched_ids","qualifiedName":"LibTmux::Workspace::X::Config::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Config::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::message","qualifiedName":"LibTmux::Workspace::X::Config::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Config::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::new","qualifiedName":"LibTmux::Workspace::X::Config::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Config::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::path","qualifiedName":"LibTmux::Workspace::X::Config::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Config::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::received","qualifiedName":"LibTmux::Workspace::X::Config::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Config::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::result","qualifiedName":"LibTmux::Workspace::X::Config::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Config::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Config","product":"workspace","publicId":"LibTmux::Workspace::X::Config::throw","qualifiedName":"LibTmux::Workspace::X::Config::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-config-throw"},{"apiScope":"exported","doc":{"summary":"An existing session conflicts with the selected repeat-application policy. No session is created until all names pass the conflict check."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Conflict","kind":"exception","modifiers":[],"name":"Conflict","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict","qualifiedName":"LibTmux::Workspace::X::Conflict","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Conflict;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":37,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Conflict::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::count","qualifiedName":"LibTmux::Workspace::X::Conflict::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Conflict::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::details","qualifiedName":"LibTmux::Workspace::X::Conflict::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Conflict::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::dispatched","qualifiedName":"LibTmux::Workspace::X::Conflict::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Conflict::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::entity","qualifiedName":"LibTmux::Workspace::X::Conflict::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Conflict::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::expected","qualifiedName":"LibTmux::Workspace::X::Conflict::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Conflict::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::matched_ids","qualifiedName":"LibTmux::Workspace::X::Conflict::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Conflict::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::message","qualifiedName":"LibTmux::Workspace::X::Conflict::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Conflict::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::new","qualifiedName":"LibTmux::Workspace::X::Conflict::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Conflict::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::path","qualifiedName":"LibTmux::Workspace::X::Conflict::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Conflict::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::received","qualifiedName":"LibTmux::Workspace::X::Conflict::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Conflict::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::result","qualifiedName":"LibTmux::Workspace::X::Conflict::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Conflict::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Conflict","product":"workspace","publicId":"LibTmux::Workspace::X::Conflict::throw","qualifiedName":"LibTmux::Workspace::X::Conflict::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-conflict-throw"},{"apiScope":"exported","doc":{"summary":"`cause` retains the original exception. `report` records completed steps, the failed step, dispatch uncertainty, and typed cleanup outcomes. Rollback affects only sessions whose creation was proven by returned core handles. See :obj:`\"load\" in LibTmux::Workspace <LibTmux::Workspace::load>` and :obj:`LibTmux::X <LibTmux::X>`."},"extends":["LibTmux::X"],"id":"LibTmux::Workspace::X::Load","kind":"exception","modifiers":[],"name":"Load","package":"LibTmux-Workspace","product":"workspace","publicId":"LibTmux::Workspace::X::Load","qualifiedName":"LibTmux::Workspace::X::Load","signatures":[{"params":[],"raw":"package LibTmux::Workspace::X::Load;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load"},{"apiScope":"exported","doc":{"summary":"For Load exceptions, return the original core or orchestration failure object."},"id":"LibTmux::Workspace::X::Load::cause","kind":"method","modifiers":[],"name":"cause","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::cause","qualifiedName":"LibTmux::Workspace::X::Load::cause","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub cause($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":42,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-cause"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::Workspace::X::Load::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::count","qualifiedName":"LibTmux::Workspace::X::Load::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::Workspace::X::Load::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::details","qualifiedName":"LibTmux::Workspace::X::Load::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::Workspace::X::Load::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::dispatched","qualifiedName":"LibTmux::Workspace::X::Load::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Load::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::entity","qualifiedName":"LibTmux::Workspace::X::Load::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::Workspace::X::Load::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::expected","qualifiedName":"LibTmux::Workspace::X::Load::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::Workspace::X::Load::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::matched_ids","qualifiedName":"LibTmux::Workspace::X::Load::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::Workspace::X::Load::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::message","qualifiedName":"LibTmux::Workspace::X::Load::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::Workspace::X::Load::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::new","qualifiedName":"LibTmux::Workspace::X::Load::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::Workspace::X::Load::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::path","qualifiedName":"LibTmux::Workspace::X::Load::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::Workspace::X::Load::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::received","qualifiedName":"LibTmux::Workspace::X::Load::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-received"},{"apiScope":"exported","doc":{"summary":"For Load exceptions, return the partial-load report. It contains created IDs, completed and failed steps, dispatch uncertainty, and cleanup failures. Each `cleanup_errors` entry contains `target` (the captured :obj:`identity <LibTmux::Entity::identity>`), `action` (`kill_session`), and `error` (the original exception). Entries follow rollback attempt order, reversing creation order. An empty array means no cleanup failure was observed. The primary :obj:`\"cause\" <LibTmux::Workspace::X::Load::cause>` and secondary exception objects retain their identity. Inspect their :obj:`dispatched <LibTmux::X::dispatched>` and :obj:`result <LibTmux::X::result>` fields without parsing prose. No I/O occurs."},"id":"LibTmux::Workspace::X::Load::report","kind":"method","modifiers":[],"name":"report","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::report","qualifiedName":"LibTmux::Workspace::X::Load::report","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub report($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":41,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-report"},{"apiScope":"exported","doc":{"body":"```perl\n    use JSON::PP ();\n    my $data = $error->report_data;\n    say JSON::PP->new->canonical->encode($data);\n```\n\nThe packaged `libtmux-workspace` CLI uses this export. Use :obj:`\"report\" <LibTmux::Workspace::X::Load::report>` when recovery needs the original typed exceptions rather than diagnostic data.","summary":"For Load exceptions, return a detached, JSON-safe report hashref. The primary cause and each cleanup error become records with `class`, `message`, known `path`, and `dispatched` (null means unknown). Core creation/load causes retain their cause chain; a repeated exception is marked `cycle`. Process results retain exit code, signal, raw wait status, and bounded stdout and stderr as `stdout_base64` and `stderr_base64` using [MIME::Base64](https://metacpan.org/pod/MIME::Base64). This diagnostic encoding does not serialize entity graphs or arbitrary exception internals. Other exceptions retain their class and string message. No I/O occurs; editing the export cannot change :obj:`\"report\" <LibTmux::Workspace::X::Load::report>` or :obj:`\"cause\" <LibTmux::Workspace::X::Load::cause>`."},"id":"LibTmux::Workspace::X::Load::report_data","kind":"method","modifiers":[],"name":"report_data","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::report_data","qualifiedName":"LibTmux::Workspace::X::Load::report_data","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub report_data($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace/X.pm","line":44,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-report_data"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::Workspace::X::Load::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::result","qualifiedName":"LibTmux::Workspace::X::Load::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::Workspace::X::Load::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux-Workspace","parent":"LibTmux::Workspace::X::Load","product":"workspace","publicId":"LibTmux::Workspace::X::Load::throw","qualifiedName":"LibTmux::Workspace::X::Load::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-x-load-throw"},{"apiScope":"exported","doc":{"summary":"Decode bounded UTF-8 JSON octets with core [JSON::PP](https://perldoc.perl.org/5.44.0/JSON::PP) and call :obj:`\"new\" <LibTmux::Workspace::new>`. Reject unsupported versions, unknown keys, invalid commands, and duplicate names. YAML is not part of this distribution."},"id":"LibTmux::Workspace::from_json","kind":"method","modifiers":[],"name":"from_json","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::from_json","qualifiedName":"LibTmux::Workspace::from_json","signatures":[{"methodKind":"call","nativeSyntax":[{"end":13,"kind":"name","start":4},{"end":27,"kind":"parameter","parameter":0,"start":22}],"params":[{"name":"json"}],"raw":"sub from_json($class, $json)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":146,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-from_json"},{"apiScope":"exported","doc":{"body":"Return one report containing created IDs, skipped names, and completed steps. On failure, rollback only sessions returned by successful creation, then throw :obj:`Load <LibTmux::Workspace::X::Load>` with original cause and partial-effect report. An uncertain creation without a returned ID cannot be rolled back safely. Existing resources are never rollback targets. Layouts apply after splitting; working directories and environments reach every initial process. Completion means command acceptance and captured state, not application readiness.","summary":"`load(server => $server, existing => 'error'|'skip')` uses public :obj:`LibTmux::Server <LibTmux::Server>` operations. It checks all session-name conflicts before creation. `error` rejects any existing target with :obj:`Conflict <LibTmux::Workspace::X::Conflict>`; `skip` leaves that entire session alone, so repeated application creates only absent sessions. A missing server permits explicit creation; other acquisition failures propagate.","examples":[{"lang":"perl","code":"use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Workspace;\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $workspace = LibTmux::Workspace->new(\n            config => {\n                schema   => 'libtmux.workspace/v1',\n                sessions => [\n                    {\n                        name    => 'workspace-example',\n                        windows => [\n                            {\n                                name   => 'api',\n                                cwd    => $root,\n                                layout => 'even-horizontal',\n                                panes  => [\n                                    {command => ['/bin/sleep', '120']},\n                                    {\n                                        command    => ['/bin/sleep', '120'],\n                                        horizontal => true\n                                    },\n                                ],\n                            }\n                        ],\n                    }\n                ],\n            }\n        );\n        die 'plan mutated state' if $workspace->plan->{mutates};\n        my $loaded = $workspace->load(server => $server);\n        die 'load failed'   unless $loaded->{status} eq 'loaded';\n        die 'panes missing' unless $server->snapshot->panes->count == 2;\n        die 'repeat did not skip'\n            unless $workspace->load(server => $server, existing => 'skip')\n            ->{skipped}->@* == 1;\n        say 'workspace load and repeat: ok';\n    }\n);\n","intro":"Complete installed-package program with an owned tmux fixture and result/cleanup assertions.","sourceUrl":"https://github.com/libtmux/libtmux-perl/blob/a1cab0324b600a5df6e34b92590b5c3bd8f79c69/examples/workspace.pl"}]},"id":"LibTmux::Workspace::load","kind":"method","modifiers":[],"name":"load","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::load","qualifiedName":"LibTmux::Workspace::load","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub load($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":179,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-load"},{"apiScope":"exported","doc":{"summary":"`new(config => $hashref)` validates and copies a `libtmux.workspace/v1` configuration. No I/O occurs. Sessions contain named windows with nonempty pane arrays. Each pane requires literal `command` arguments or an explicit `shell_command`. Environment values inherit from workspace, session, and window, with pane values taking precedence. All configuration errors throw :obj:`Config <LibTmux::Workspace::X::Config>`."},"id":"LibTmux::Workspace::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::new","qualifiedName":"LibTmux::Workspace::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub new($class, %args)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":47,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-new"},{"apiScope":"exported","doc":{"summary":"`plan(existing => 'error'|'skip')` returns a fresh data plan in input order. It performs no tmux I/O or mutations. A dry-run does not prove live availability or command success. Exports share no mutable arrays with the loader. No context-dependent return values are used."},"id":"LibTmux::Workspace::plan","kind":"method","modifiers":[],"name":"plan","package":"LibTmux-Workspace","parent":"LibTmux::Workspace","product":"workspace","publicId":"LibTmux::Workspace::plan","qualifiedName":"LibTmux::Workspace::plan","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4},{"end":21,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"args","variadic":"keyword"}],"raw":"sub plan($self, %args)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/workspace/lib/LibTmux/Workspace.pm","line":165,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-workspace-plan"},{"apiScope":"exported","doc":{"body":"\n## DESCRIPTION\n\nErrors stringify with class, path, and message. :obj:`\"Creation\" <LibTmux::X::Creation>` retains its original acquisition exception separately through `cause`. `details` returns diagnostic fields. Acquisition failures never represent an empty selection.\n\n\n## CARDINALITY AND DATA FAILURES\n\n\n## DIAGNOSTICS\n\n`message`, `path`, `entity`, `expected`, `received`, `matched_ids`, `count`, `result`, `dispatched`, and `details` expose applicable fields. See :obj:`\"one\" in LibTmux::Selection <LibTmux::Selection::one>`, :obj:`\"new\" in LibTmux::Filter <LibTmux::Filter::new>`, and :obj:`LibTmux::Server <LibTmux::Server>` for failure boundaries.\n\n","summary":"Typed failures with readable diagnostics"},"id":"LibTmux::X","kind":"class","modifiers":[],"name":"X","package":"LibTmux","product":"core","publicId":"LibTmux::X","qualifiedName":"LibTmux::X","signatures":[{"params":[],"raw":"package LibTmux::X;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":1,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x"},{"apiScope":"exported","doc":{"summary":"Observed generations or topology changed during capture."},"extends":["LibTmux::X"],"id":"LibTmux::X::AcquisitionRace","kind":"exception","modifiers":[],"name":"AcquisitionRace","package":"LibTmux","product":"core","publicId":"LibTmux::X::AcquisitionRace","qualifiedName":"LibTmux::X::AcquisitionRace","signatures":[{"params":[],"raw":"package LibTmux::X::AcquisitionRace;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":55,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::AcquisitionRace::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::count","qualifiedName":"LibTmux::X::AcquisitionRace::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::AcquisitionRace::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::details","qualifiedName":"LibTmux::X::AcquisitionRace::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::AcquisitionRace::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::dispatched","qualifiedName":"LibTmux::X::AcquisitionRace::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::AcquisitionRace::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::entity","qualifiedName":"LibTmux::X::AcquisitionRace::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::AcquisitionRace::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::expected","qualifiedName":"LibTmux::X::AcquisitionRace::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::AcquisitionRace::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::matched_ids","qualifiedName":"LibTmux::X::AcquisitionRace::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::AcquisitionRace::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::message","qualifiedName":"LibTmux::X::AcquisitionRace::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::AcquisitionRace::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::new","qualifiedName":"LibTmux::X::AcquisitionRace::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::AcquisitionRace::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::path","qualifiedName":"LibTmux::X::AcquisitionRace::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::AcquisitionRace::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::received","qualifiedName":"LibTmux::X::AcquisitionRace::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::AcquisitionRace::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::result","qualifiedName":"LibTmux::X::AcquisitionRace::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::AcquisitionRace::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::AcquisitionRace","product":"core","publicId":"LibTmux::X::AcquisitionRace::throw","qualifiedName":"LibTmux::X::AcquisitionRace::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-acquisitionrace-throw"},{"apiScope":"exported","doc":{"summary":"Execution was cancelled; cancellation does not roll back effects."},"extends":["LibTmux::X"],"id":"LibTmux::X::Cancelled","kind":"exception","modifiers":[],"name":"Cancelled","package":"LibTmux","product":"core","publicId":"LibTmux::X::Cancelled","qualifiedName":"LibTmux::X::Cancelled","signatures":[{"params":[],"raw":"package LibTmux::X::Cancelled;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":41,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Cancelled::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::count","qualifiedName":"LibTmux::X::Cancelled::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Cancelled::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::details","qualifiedName":"LibTmux::X::Cancelled::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Cancelled::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::dispatched","qualifiedName":"LibTmux::X::Cancelled::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Cancelled::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::entity","qualifiedName":"LibTmux::X::Cancelled::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Cancelled::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::expected","qualifiedName":"LibTmux::X::Cancelled::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Cancelled::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::matched_ids","qualifiedName":"LibTmux::X::Cancelled::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Cancelled::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::message","qualifiedName":"LibTmux::X::Cancelled::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Cancelled::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::new","qualifiedName":"LibTmux::X::Cancelled::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Cancelled::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::path","qualifiedName":"LibTmux::X::Cancelled::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Cancelled::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::received","qualifiedName":"LibTmux::X::Cancelled::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Cancelled::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::result","qualifiedName":"LibTmux::X::Cancelled::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Cancelled::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Cancelled","product":"core","publicId":"LibTmux::X::Cancelled::throw","qualifiedName":"LibTmux::X::Cancelled::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-cancelled-throw"},{"apiScope":"exported","doc":{"summary":"A tmux record or field could not be decoded."},"extends":["LibTmux::X"],"id":"LibTmux::X::Codec","kind":"exception","modifiers":[],"name":"Codec","package":"LibTmux","product":"core","publicId":"LibTmux::X::Codec","qualifiedName":"LibTmux::X::Codec","signatures":[{"params":[],"raw":"package LibTmux::X::Codec;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":47,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Codec::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::count","qualifiedName":"LibTmux::X::Codec::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Codec::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::details","qualifiedName":"LibTmux::X::Codec::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Codec::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::dispatched","qualifiedName":"LibTmux::X::Codec::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Codec::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::entity","qualifiedName":"LibTmux::X::Codec::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Codec::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::expected","qualifiedName":"LibTmux::X::Codec::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Codec::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::matched_ids","qualifiedName":"LibTmux::X::Codec::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Codec::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::message","qualifiedName":"LibTmux::X::Codec::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Codec::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::new","qualifiedName":"LibTmux::X::Codec::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Codec::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::path","qualifiedName":"LibTmux::X::Codec::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Codec::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::received","qualifiedName":"LibTmux::X::Codec::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Codec::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::result","qualifiedName":"LibTmux::X::Codec::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Codec::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Codec","product":"core","publicId":"LibTmux::X::Codec::throw","qualifiedName":"LibTmux::X::Codec::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-codec-throw"},{"apiScope":"exported","doc":{"summary":"tmux reported nonzero status; result retains stdout/stderr/status."},"extends":["LibTmux::X"],"id":"LibTmux::X::Command","kind":"exception","modifiers":[],"name":"Command","package":"LibTmux","product":"core","publicId":"LibTmux::X::Command","qualifiedName":"LibTmux::X::Command","signatures":[{"params":[],"raw":"package LibTmux::X::Command;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":49,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Command::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::count","qualifiedName":"LibTmux::X::Command::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Command::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::details","qualifiedName":"LibTmux::X::Command::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Command::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::dispatched","qualifiedName":"LibTmux::X::Command::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Command::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::entity","qualifiedName":"LibTmux::X::Command::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Command::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::expected","qualifiedName":"LibTmux::X::Command::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Command::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::matched_ids","qualifiedName":"LibTmux::X::Command::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Command::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::message","qualifiedName":"LibTmux::X::Command::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Command::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::new","qualifiedName":"LibTmux::X::Command::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Command::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::path","qualifiedName":"LibTmux::X::Command::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Command::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::received","qualifiedName":"LibTmux::X::Command::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Command::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::result","qualifiedName":"LibTmux::X::Command::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Command::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Command","product":"core","publicId":"LibTmux::X::Command::throw","qualifiedName":"LibTmux::X::Command::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-command-throw"},{"apiScope":"exported","doc":{"summary":"A creation command succeeded but subsequent receipt decoding or capture failed. `created` returns a minimal generation-scoped entity handle when the command's receipt was decoded; other fields remain unloaded. `cause` preserves the original acquisition failure. `dispatched` is true. The returned handle permits explicit, generation-checked cleanup; absent receipts leave effects uncertain. See :obj:`\"new_session\" in LibTmux::Server <LibTmux::Server::new_session>`."},"extends":["LibTmux::X"],"id":"LibTmux::X::Creation","kind":"exception","modifiers":[],"name":"Creation","package":"LibTmux","product":"core","publicId":"LibTmux::X::Creation","qualifiedName":"LibTmux::X::Creation","signatures":[{"params":[],"raw":"package LibTmux::X::Creation;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":59,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation"},{"apiScope":"exported","doc":{"summary":"Return the original acquisition exception for :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>`."},"id":"LibTmux::X::Creation::cause","kind":"method","modifiers":[],"name":"cause","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::cause","qualifiedName":"LibTmux::X::Creation::cause","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub cause($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":62,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-cause"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Creation::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::count","qualifiedName":"LibTmux::X::Creation::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-count"},{"apiScope":"exported","doc":{"summary":"Creation failures expose a minimal generation-scoped entity receipt, or undef. Only :obj:`\"Creation\" in LibTmux::X <LibTmux::X::Creation>` provides this method."},"id":"LibTmux::X::Creation::created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::created","qualifiedName":"LibTmux::X::Creation::created","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub created($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":61,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-created"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Creation::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::details","qualifiedName":"LibTmux::X::Creation::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Creation::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::dispatched","qualifiedName":"LibTmux::X::Creation::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Creation::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::entity","qualifiedName":"LibTmux::X::Creation::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Creation::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::expected","qualifiedName":"LibTmux::X::Creation::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Creation::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::matched_ids","qualifiedName":"LibTmux::X::Creation::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Creation::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::message","qualifiedName":"LibTmux::X::Creation::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Creation::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::new","qualifiedName":"LibTmux::X::Creation::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Creation::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::path","qualifiedName":"LibTmux::X::Creation::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Creation::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::received","qualifiedName":"LibTmux::X::Creation::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Creation::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::result","qualifiedName":"LibTmux::X::Creation::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Creation::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Creation","product":"core","publicId":"LibTmux::X::Creation::throw","qualifiedName":"LibTmux::X::Creation::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-creation-throw"},{"apiScope":"exported","doc":{"summary":"Invalid operation or transport argument before dispatch."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidArgument","kind":"exception","modifiers":[],"name":"InvalidArgument","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidArgument","qualifiedName":"LibTmux::X::InvalidArgument","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidArgument;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":21,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidArgument::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::count","qualifiedName":"LibTmux::X::InvalidArgument::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidArgument::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::details","qualifiedName":"LibTmux::X::InvalidArgument::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidArgument::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::dispatched","qualifiedName":"LibTmux::X::InvalidArgument::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidArgument::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::entity","qualifiedName":"LibTmux::X::InvalidArgument::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidArgument::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::expected","qualifiedName":"LibTmux::X::InvalidArgument::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidArgument::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::matched_ids","qualifiedName":"LibTmux::X::InvalidArgument::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidArgument::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::message","qualifiedName":"LibTmux::X::InvalidArgument::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidArgument::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::new","qualifiedName":"LibTmux::X::InvalidArgument::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidArgument::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::path","qualifiedName":"LibTmux::X::InvalidArgument::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidArgument::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::received","qualifiedName":"LibTmux::X::InvalidArgument::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidArgument::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::result","qualifiedName":"LibTmux::X::InvalidArgument::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidArgument::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidArgument","product":"core","publicId":"LibTmux::X::InvalidArgument::throw","qualifiedName":"LibTmux::X::InvalidArgument::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidargument-throw"},{"apiScope":"exported","doc":{"summary":"Invalid criteria data; path, expected, and received describe the boundary."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidFilter","kind":"exception","modifiers":[],"name":"InvalidFilter","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidFilter","qualifiedName":"LibTmux::X::InvalidFilter","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidFilter;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":25,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidFilter::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::count","qualifiedName":"LibTmux::X::InvalidFilter::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidFilter::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::details","qualifiedName":"LibTmux::X::InvalidFilter::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidFilter::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::dispatched","qualifiedName":"LibTmux::X::InvalidFilter::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidFilter::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::entity","qualifiedName":"LibTmux::X::InvalidFilter::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidFilter::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::expected","qualifiedName":"LibTmux::X::InvalidFilter::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidFilter::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::matched_ids","qualifiedName":"LibTmux::X::InvalidFilter::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidFilter::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::message","qualifiedName":"LibTmux::X::InvalidFilter::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidFilter::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::new","qualifiedName":"LibTmux::X::InvalidFilter::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidFilter::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::path","qualifiedName":"LibTmux::X::InvalidFilter::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidFilter::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::received","qualifiedName":"LibTmux::X::InvalidFilter::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidFilter::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::result","qualifiedName":"LibTmux::X::InvalidFilter::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidFilter::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidFilter","product":"core","publicId":"LibTmux::X::InvalidFilter::throw","qualifiedName":"LibTmux::X::InvalidFilter::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidfilter-throw"},{"apiScope":"exported","doc":{"summary":"Undefined, hole, wrong-kind, or incompatible-generation membership."},"extends":["LibTmux::X"],"id":"LibTmux::X::InvalidSelection","kind":"exception","modifiers":[],"name":"InvalidSelection","package":"LibTmux","product":"core","publicId":"LibTmux::X::InvalidSelection","qualifiedName":"LibTmux::X::InvalidSelection","signatures":[{"params":[],"raw":"package LibTmux::X::InvalidSelection;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":23,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::InvalidSelection::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::count","qualifiedName":"LibTmux::X::InvalidSelection::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::InvalidSelection::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::details","qualifiedName":"LibTmux::X::InvalidSelection::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::InvalidSelection::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::dispatched","qualifiedName":"LibTmux::X::InvalidSelection::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::InvalidSelection::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::entity","qualifiedName":"LibTmux::X::InvalidSelection::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::InvalidSelection::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::expected","qualifiedName":"LibTmux::X::InvalidSelection::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::InvalidSelection::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::matched_ids","qualifiedName":"LibTmux::X::InvalidSelection::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::InvalidSelection::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::message","qualifiedName":"LibTmux::X::InvalidSelection::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::InvalidSelection::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::new","qualifiedName":"LibTmux::X::InvalidSelection::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::InvalidSelection::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::path","qualifiedName":"LibTmux::X::InvalidSelection::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::InvalidSelection::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::received","qualifiedName":"LibTmux::X::InvalidSelection::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::InvalidSelection::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::result","qualifiedName":"LibTmux::X::InvalidSelection::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::InvalidSelection::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::InvalidSelection","product":"core","publicId":"LibTmux::X::InvalidSelection::throw","qualifiedName":"LibTmux::X::InvalidSelection::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-invalidselection-throw"},{"apiScope":"exported","doc":{"summary":"At least two occurrences matched. matched_ids preserves occurrence diagnostics."},"extends":["LibTmux::X"],"id":"LibTmux::X::MultipleMatches","kind":"exception","modifiers":[],"name":"MultipleMatches","package":"LibTmux","product":"core","publicId":"LibTmux::X::MultipleMatches","qualifiedName":"LibTmux::X::MultipleMatches","signatures":[{"params":[],"raw":"package LibTmux::X::MultipleMatches;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":29,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::MultipleMatches::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::count","qualifiedName":"LibTmux::X::MultipleMatches::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::MultipleMatches::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::details","qualifiedName":"LibTmux::X::MultipleMatches::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::MultipleMatches::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::dispatched","qualifiedName":"LibTmux::X::MultipleMatches::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::MultipleMatches::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::entity","qualifiedName":"LibTmux::X::MultipleMatches::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::MultipleMatches::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::expected","qualifiedName":"LibTmux::X::MultipleMatches::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::MultipleMatches::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::matched_ids","qualifiedName":"LibTmux::X::MultipleMatches::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::MultipleMatches::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::message","qualifiedName":"LibTmux::X::MultipleMatches::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::MultipleMatches::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::new","qualifiedName":"LibTmux::X::MultipleMatches::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::MultipleMatches::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::path","qualifiedName":"LibTmux::X::MultipleMatches::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::MultipleMatches::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::received","qualifiedName":"LibTmux::X::MultipleMatches::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::MultipleMatches::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::result","qualifiedName":"LibTmux::X::MultipleMatches::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::MultipleMatches::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::MultipleMatches","product":"core","publicId":"LibTmux::X::MultipleMatches::throw","qualifiedName":"LibTmux::X::MultipleMatches::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-multiplematches-throw"},{"apiScope":"exported","doc":{"summary":"No occurrence matched one()."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoMatch","kind":"exception","modifiers":[],"name":"NoMatch","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoMatch","qualifiedName":"LibTmux::X::NoMatch","signatures":[{"params":[],"raw":"package LibTmux::X::NoMatch;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":27,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoMatch::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::count","qualifiedName":"LibTmux::X::NoMatch::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoMatch::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::details","qualifiedName":"LibTmux::X::NoMatch::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoMatch::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::dispatched","qualifiedName":"LibTmux::X::NoMatch::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoMatch::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::entity","qualifiedName":"LibTmux::X::NoMatch::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoMatch::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::expected","qualifiedName":"LibTmux::X::NoMatch::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoMatch::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::matched_ids","qualifiedName":"LibTmux::X::NoMatch::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoMatch::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::message","qualifiedName":"LibTmux::X::NoMatch::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoMatch::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::new","qualifiedName":"LibTmux::X::NoMatch::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoMatch::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::path","qualifiedName":"LibTmux::X::NoMatch::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoMatch::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::received","qualifiedName":"LibTmux::X::NoMatch::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoMatch::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::result","qualifiedName":"LibTmux::X::NoMatch::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoMatch::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoMatch","product":"core","publicId":"LibTmux::X::NoMatch::throw","qualifiedName":"LibTmux::X::NoMatch::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nomatch-throw"},{"apiScope":"exported","doc":{"summary":"The selected server cannot be reached."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoServer","kind":"exception","modifiers":[],"name":"NoServer","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoServer","qualifiedName":"LibTmux::X::NoServer","signatures":[{"params":[],"raw":"package LibTmux::X::NoServer;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":51,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoServer::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::count","qualifiedName":"LibTmux::X::NoServer::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoServer::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::details","qualifiedName":"LibTmux::X::NoServer::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoServer::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::dispatched","qualifiedName":"LibTmux::X::NoServer::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoServer::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::entity","qualifiedName":"LibTmux::X::NoServer::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoServer::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::expected","qualifiedName":"LibTmux::X::NoServer::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoServer::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::matched_ids","qualifiedName":"LibTmux::X::NoServer::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoServer::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::message","qualifiedName":"LibTmux::X::NoServer::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoServer::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::new","qualifiedName":"LibTmux::X::NoServer::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoServer::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::path","qualifiedName":"LibTmux::X::NoServer::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoServer::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::received","qualifiedName":"LibTmux::X::NoServer::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoServer::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::result","qualifiedName":"LibTmux::X::NoServer::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoServer::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoServer","product":"core","publicId":"LibTmux::X::NoServer::throw","qualifiedName":"LibTmux::X::NoServer::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-noserver-throw"},{"apiScope":"exported","doc":{"summary":"The selected stable target no longer exists. Native result diagnostics are retained. This differs from a stale generation and from an arbitrary command failure; acquire a new snapshot before choosing recovery."},"extends":["LibTmux::X"],"id":"LibTmux::X::NoSuchTarget","kind":"exception","modifiers":[],"name":"NoSuchTarget","package":"LibTmux","product":"core","publicId":"LibTmux::X::NoSuchTarget","qualifiedName":"LibTmux::X::NoSuchTarget","signatures":[{"params":[],"raw":"package LibTmux::X::NoSuchTarget;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":65,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::NoSuchTarget::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::count","qualifiedName":"LibTmux::X::NoSuchTarget::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::NoSuchTarget::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::details","qualifiedName":"LibTmux::X::NoSuchTarget::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::NoSuchTarget::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::dispatched","qualifiedName":"LibTmux::X::NoSuchTarget::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::NoSuchTarget::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::entity","qualifiedName":"LibTmux::X::NoSuchTarget::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::NoSuchTarget::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::expected","qualifiedName":"LibTmux::X::NoSuchTarget::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::NoSuchTarget::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::matched_ids","qualifiedName":"LibTmux::X::NoSuchTarget::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::NoSuchTarget::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::message","qualifiedName":"LibTmux::X::NoSuchTarget::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::NoSuchTarget::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::new","qualifiedName":"LibTmux::X::NoSuchTarget::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::NoSuchTarget::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::path","qualifiedName":"LibTmux::X::NoSuchTarget::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::NoSuchTarget::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::received","qualifiedName":"LibTmux::X::NoSuchTarget::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::NoSuchTarget::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::result","qualifiedName":"LibTmux::X::NoSuchTarget::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::NoSuchTarget::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::NoSuchTarget","product":"core","publicId":"LibTmux::X::NoSuchTarget::throw","qualifiedName":"LibTmux::X::NoSuchTarget::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-nosuchtarget-throw"},{"apiScope":"exported","doc":{"summary":"Retained process output exceeded the configured bound."},"extends":["LibTmux::X"],"id":"LibTmux::X::OutputLimit","kind":"exception","modifiers":[],"name":"OutputLimit","package":"LibTmux","product":"core","publicId":"LibTmux::X::OutputLimit","qualifiedName":"LibTmux::X::OutputLimit","signatures":[{"params":[],"raw":"package LibTmux::X::OutputLimit;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":43,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::OutputLimit::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::count","qualifiedName":"LibTmux::X::OutputLimit::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::OutputLimit::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::details","qualifiedName":"LibTmux::X::OutputLimit::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::OutputLimit::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::dispatched","qualifiedName":"LibTmux::X::OutputLimit::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::OutputLimit::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::entity","qualifiedName":"LibTmux::X::OutputLimit::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::OutputLimit::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::expected","qualifiedName":"LibTmux::X::OutputLimit::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::OutputLimit::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::matched_ids","qualifiedName":"LibTmux::X::OutputLimit::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::OutputLimit::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::message","qualifiedName":"LibTmux::X::OutputLimit::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::OutputLimit::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::new","qualifiedName":"LibTmux::X::OutputLimit::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::OutputLimit::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::path","qualifiedName":"LibTmux::X::OutputLimit::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::OutputLimit::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::received","qualifiedName":"LibTmux::X::OutputLimit::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::OutputLimit::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::result","qualifiedName":"LibTmux::X::OutputLimit::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::OutputLimit::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::OutputLimit","product":"core","publicId":"LibTmux::X::OutputLimit::throw","qualifiedName":"LibTmux::X::OutputLimit::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-outputlimit-throw"},{"apiScope":"exported","doc":{"summary":"Native candidates disagree with captured local matches, or an expert native query returned an uncaptured ID. `details->{verification}` contains the detached :obj:`\"VERIFICATION REPORT\" in LibTmux::Server <LibTmux::Server#VERIFICATION%20REPORT>`. The cause may be concurrent change, a translation defect or backend semantics; the comparison does not identify it. :obj:`\"query_panes\" in LibTmux::Server <LibTmux::Server::query_panes>` throws this for require or expert queries, while auto reports fallback through its optional observer."},"extends":["LibTmux::X"],"id":"LibTmux::X::QueryMismatch","kind":"exception","modifiers":[],"name":"QueryMismatch","package":"LibTmux","product":"core","publicId":"LibTmux::X::QueryMismatch","qualifiedName":"LibTmux::X::QueryMismatch","signatures":[{"params":[],"raw":"package LibTmux::X::QueryMismatch;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":57,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::QueryMismatch::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::count","qualifiedName":"LibTmux::X::QueryMismatch::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::QueryMismatch::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::details","qualifiedName":"LibTmux::X::QueryMismatch::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::QueryMismatch::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::dispatched","qualifiedName":"LibTmux::X::QueryMismatch::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::QueryMismatch::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::entity","qualifiedName":"LibTmux::X::QueryMismatch::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::QueryMismatch::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::expected","qualifiedName":"LibTmux::X::QueryMismatch::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::QueryMismatch::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::matched_ids","qualifiedName":"LibTmux::X::QueryMismatch::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::QueryMismatch::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::message","qualifiedName":"LibTmux::X::QueryMismatch::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::QueryMismatch::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::new","qualifiedName":"LibTmux::X::QueryMismatch::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::QueryMismatch::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::path","qualifiedName":"LibTmux::X::QueryMismatch::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::QueryMismatch::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::received","qualifiedName":"LibTmux::X::QueryMismatch::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::QueryMismatch::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::result","qualifiedName":"LibTmux::X::QueryMismatch::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::QueryMismatch::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::QueryMismatch","product":"core","publicId":"LibTmux::X::QueryMismatch::throw","qualifiedName":"LibTmux::X::QueryMismatch::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-querymismatch-throw"},{"apiScope":"exported","doc":{"summary":"The executable could not start; dispatch is distinguished from command failure."},"extends":["LibTmux::X"],"id":"LibTmux::X::Spawn","kind":"exception","modifiers":[],"name":"Spawn","package":"LibTmux","product":"core","publicId":"LibTmux::X::Spawn","qualifiedName":"LibTmux::X::Spawn","signatures":[{"params":[],"raw":"package LibTmux::X::Spawn;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":37,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Spawn::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::count","qualifiedName":"LibTmux::X::Spawn::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Spawn::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::details","qualifiedName":"LibTmux::X::Spawn::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Spawn::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::dispatched","qualifiedName":"LibTmux::X::Spawn::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Spawn::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::entity","qualifiedName":"LibTmux::X::Spawn::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Spawn::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::expected","qualifiedName":"LibTmux::X::Spawn::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Spawn::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::matched_ids","qualifiedName":"LibTmux::X::Spawn::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Spawn::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::message","qualifiedName":"LibTmux::X::Spawn::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Spawn::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::new","qualifiedName":"LibTmux::X::Spawn::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Spawn::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::path","qualifiedName":"LibTmux::X::Spawn::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Spawn::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::received","qualifiedName":"LibTmux::X::Spawn::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Spawn::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::result","qualifiedName":"LibTmux::X::Spawn::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Spawn::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Spawn","product":"core","publicId":"LibTmux::X::Spawn::throw","qualifiedName":"LibTmux::X::Spawn::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-spawn-throw"},{"apiScope":"exported","doc":{"summary":"A captured generation or contextual target no longer identifies the same resource."},"extends":["LibTmux::X"],"id":"LibTmux::X::StaleReference","kind":"exception","modifiers":[],"name":"StaleReference","package":"LibTmux","product":"core","publicId":"LibTmux::X::StaleReference","qualifiedName":"LibTmux::X::StaleReference","signatures":[{"params":[],"raw":"package LibTmux::X::StaleReference;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":53,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::StaleReference::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::count","qualifiedName":"LibTmux::X::StaleReference::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::StaleReference::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::details","qualifiedName":"LibTmux::X::StaleReference::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::StaleReference::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::dispatched","qualifiedName":"LibTmux::X::StaleReference::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::StaleReference::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::entity","qualifiedName":"LibTmux::X::StaleReference::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::StaleReference::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::expected","qualifiedName":"LibTmux::X::StaleReference::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::StaleReference::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::matched_ids","qualifiedName":"LibTmux::X::StaleReference::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::StaleReference::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::message","qualifiedName":"LibTmux::X::StaleReference::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::StaleReference::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::new","qualifiedName":"LibTmux::X::StaleReference::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::StaleReference::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::path","qualifiedName":"LibTmux::X::StaleReference::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::StaleReference::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::received","qualifiedName":"LibTmux::X::StaleReference::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::StaleReference::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::result","qualifiedName":"LibTmux::X::StaleReference::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::StaleReference::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::StaleReference","product":"core","publicId":"LibTmux::X::StaleReference::throw","qualifiedName":"LibTmux::X::StaleReference::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-stalereference-throw"},{"apiScope":"exported","doc":{"summary":"Execution exceeded its deadline; effects may already have occurred."},"extends":["LibTmux::X"],"id":"LibTmux::X::Timeout","kind":"exception","modifiers":[],"name":"Timeout","package":"LibTmux","product":"core","publicId":"LibTmux::X::Timeout","qualifiedName":"LibTmux::X::Timeout","signatures":[{"params":[],"raw":"package LibTmux::X::Timeout;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":39,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Timeout::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::count","qualifiedName":"LibTmux::X::Timeout::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Timeout::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::details","qualifiedName":"LibTmux::X::Timeout::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Timeout::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::dispatched","qualifiedName":"LibTmux::X::Timeout::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Timeout::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::entity","qualifiedName":"LibTmux::X::Timeout::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Timeout::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::expected","qualifiedName":"LibTmux::X::Timeout::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Timeout::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::matched_ids","qualifiedName":"LibTmux::X::Timeout::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Timeout::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::message","qualifiedName":"LibTmux::X::Timeout::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Timeout::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::new","qualifiedName":"LibTmux::X::Timeout::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Timeout::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::path","qualifiedName":"LibTmux::X::Timeout::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Timeout::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::received","qualifiedName":"LibTmux::X::Timeout::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Timeout::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::result","qualifiedName":"LibTmux::X::Timeout::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Timeout::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Timeout","product":"core","publicId":"LibTmux::X::Timeout::throw","qualifiedName":"LibTmux::X::Timeout::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-timeout-throw"},{"apiScope":"exported","doc":{"summary":"Process supervision or result framing failed."},"extends":["LibTmux::X"],"id":"LibTmux::X::Transport","kind":"exception","modifiers":[],"name":"Transport","package":"LibTmux","product":"core","publicId":"LibTmux::X::Transport","qualifiedName":"LibTmux::X::Transport","signatures":[{"params":[],"raw":"package LibTmux::X::Transport;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":45,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Transport::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::count","qualifiedName":"LibTmux::X::Transport::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Transport::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::details","qualifiedName":"LibTmux::X::Transport::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Transport::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::dispatched","qualifiedName":"LibTmux::X::Transport::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Transport::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::entity","qualifiedName":"LibTmux::X::Transport::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Transport::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::expected","qualifiedName":"LibTmux::X::Transport::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Transport::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::matched_ids","qualifiedName":"LibTmux::X::Transport::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Transport::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::message","qualifiedName":"LibTmux::X::Transport::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Transport::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::new","qualifiedName":"LibTmux::X::Transport::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Transport::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::path","qualifiedName":"LibTmux::X::Transport::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Transport::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::received","qualifiedName":"LibTmux::X::Transport::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Transport::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::result","qualifiedName":"LibTmux::X::Transport::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Transport::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Transport","product":"core","publicId":"LibTmux::X::Transport::throw","qualifiedName":"LibTmux::X::Transport::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-transport-throw"},{"apiScope":"exported","doc":{"summary":"A required field or relation is not available in captured data."},"extends":["LibTmux::X"],"id":"LibTmux::X::Unloaded","kind":"exception","modifiers":[],"name":"Unloaded","package":"LibTmux","product":"core","publicId":"LibTmux::X::Unloaded","qualifiedName":"LibTmux::X::Unloaded","signatures":[{"params":[],"raw":"package LibTmux::X::Unloaded;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":31,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Unloaded::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::count","qualifiedName":"LibTmux::X::Unloaded::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Unloaded::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::details","qualifiedName":"LibTmux::X::Unloaded::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Unloaded::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::dispatched","qualifiedName":"LibTmux::X::Unloaded::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Unloaded::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::entity","qualifiedName":"LibTmux::X::Unloaded::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Unloaded::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::expected","qualifiedName":"LibTmux::X::Unloaded::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Unloaded::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::matched_ids","qualifiedName":"LibTmux::X::Unloaded::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Unloaded::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::message","qualifiedName":"LibTmux::X::Unloaded::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Unloaded::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::new","qualifiedName":"LibTmux::X::Unloaded::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Unloaded::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::path","qualifiedName":"LibTmux::X::Unloaded::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Unloaded::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::received","qualifiedName":"LibTmux::X::Unloaded::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Unloaded::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::result","qualifiedName":"LibTmux::X::Unloaded::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Unloaded::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Unloaded","product":"core","publicId":"LibTmux::X::Unloaded::throw","qualifiedName":"LibTmux::X::Unloaded::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unloaded-throw"},{"apiScope":"exported","doc":{"summary":"A daemon or execution capability is unavailable."},"extends":["LibTmux::X"],"id":"LibTmux::X::Unsupported","kind":"exception","modifiers":[],"name":"Unsupported","package":"LibTmux","product":"core","publicId":"LibTmux::X::Unsupported","qualifiedName":"LibTmux::X::Unsupported","signatures":[{"params":[],"raw":"package LibTmux::X::Unsupported;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":35,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::Unsupported::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::count","qualifiedName":"LibTmux::X::Unsupported::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::Unsupported::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::details","qualifiedName":"LibTmux::X::Unsupported::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::Unsupported::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::dispatched","qualifiedName":"LibTmux::X::Unsupported::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::Unsupported::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::entity","qualifiedName":"LibTmux::X::Unsupported::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::Unsupported::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::expected","qualifiedName":"LibTmux::X::Unsupported::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::Unsupported::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::matched_ids","qualifiedName":"LibTmux::X::Unsupported::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::Unsupported::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::message","qualifiedName":"LibTmux::X::Unsupported::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::Unsupported::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::new","qualifiedName":"LibTmux::X::Unsupported::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::Unsupported::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::path","qualifiedName":"LibTmux::X::Unsupported::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::Unsupported::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::received","qualifiedName":"LibTmux::X::Unsupported::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::Unsupported::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::result","qualifiedName":"LibTmux::X::Unsupported::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::Unsupported::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::Unsupported","product":"core","publicId":"LibTmux::X::Unsupported::throw","qualifiedName":"LibTmux::X::Unsupported::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupported-throw"},{"apiScope":"exported","doc":{"summary":"A local value has no supported portable wire representation."},"extends":["LibTmux::X"],"id":"LibTmux::X::UnsupportedValue","kind":"exception","modifiers":[],"name":"UnsupportedValue","package":"LibTmux","product":"core","publicId":"LibTmux::X::UnsupportedValue","qualifiedName":"LibTmux::X::UnsupportedValue","signatures":[{"params":[],"raw":"package LibTmux::X::UnsupportedValue;"}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":33,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::UnsupportedValue::count","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::count","qualifiedName":"LibTmux::X::UnsupportedValue::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::UnsupportedValue::details","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::details","qualifiedName":"LibTmux::X::UnsupportedValue::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::UnsupportedValue::dispatched","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::dispatched","qualifiedName":"LibTmux::X::UnsupportedValue::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::UnsupportedValue::entity","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::entity","qualifiedName":"LibTmux::X::UnsupportedValue::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::UnsupportedValue::expected","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::expected","qualifiedName":"LibTmux::X::UnsupportedValue::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::UnsupportedValue::matched_ids","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::matched_ids","qualifiedName":"LibTmux::X::UnsupportedValue::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::UnsupportedValue::message","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::message","qualifiedName":"LibTmux::X::UnsupportedValue::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::UnsupportedValue::new","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::new","qualifiedName":"LibTmux::X::UnsupportedValue::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::UnsupportedValue::path","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::path","qualifiedName":"LibTmux::X::UnsupportedValue::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::UnsupportedValue::received","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::received","qualifiedName":"LibTmux::X::UnsupportedValue::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::UnsupportedValue::result","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::result","qualifiedName":"LibTmux::X::UnsupportedValue::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::UnsupportedValue::throw","inheritedFrom":"LibTmux::X","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X::UnsupportedValue","product":"core","publicId":"LibTmux::X::UnsupportedValue::throw","qualifiedName":"LibTmux::X::UnsupportedValue::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-unsupportedvalue-throw"},{"apiScope":"exported","doc":{"summary":"Return the observed cardinality lower bound where applicable."},"id":"LibTmux::X::count","kind":"method","modifiers":[],"name":"count","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::count","qualifiedName":"LibTmux::X::count","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4}],"params":[],"raw":"sub count($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":16,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-count"},{"apiScope":"exported","doc":{"summary":"Return a fresh shallow hashref of diagnostic fields. Causes and entity handles retain their identity."},"id":"LibTmux::X::details","kind":"method","modifiers":[],"name":"details","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::details","qualifiedName":"LibTmux::X::details","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub details($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":19,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-details"},{"apiScope":"exported","doc":{"summary":"Return whether the request was submitted where known; undef means no dispatch evidence was recorded. This never proves rollback."},"id":"LibTmux::X::dispatched","kind":"method","modifiers":[],"name":"dispatched","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::dispatched","qualifiedName":"LibTmux::X::dispatched","signatures":[{"methodKind":"call","nativeSyntax":[{"end":14,"kind":"name","start":4}],"params":[],"raw":"sub dispatched($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":18,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-dispatched"},{"apiScope":"exported","doc":{"summary":"Return the entity kind, or undef when inapplicable."},"id":"LibTmux::X::entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::entity","qualifiedName":"LibTmux::X::entity","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub entity($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":12,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-entity"},{"apiScope":"exported","doc":{"summary":"Return the expected operand description, or undef."},"id":"LibTmux::X::expected","kind":"method","modifiers":[],"name":"expected","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::expected","qualifiedName":"LibTmux::X::expected","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub expected($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":13,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-expected"},{"apiScope":"exported","doc":{"summary":"Return a fresh arrayref of observed matching IDs, including duplicate occurrences."},"id":"LibTmux::X::matched_ids","kind":"method","modifiers":[],"name":"matched_ids","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::matched_ids","qualifiedName":"LibTmux::X::matched_ids","signatures":[{"methodKind":"call","nativeSyntax":[{"end":15,"kind":"name","start":4}],"params":[],"raw":"sub matched_ids($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":15,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-matched_ids"},{"apiScope":"exported","doc":{"summary":"Return the human-readable failure description."},"id":"LibTmux::X::message","kind":"method","modifiers":[],"name":"message","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::message","qualifiedName":"LibTmux::X::message","signatures":[{"methodKind":"call","nativeSyntax":[{"end":11,"kind":"name","start":4}],"params":[],"raw":"sub message($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":10,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-message"},{"apiScope":"exported","doc":{"summary":"`new(%details)` constructs an exception object without throwing or I/O."},"id":"LibTmux::X::new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::new","qualifiedName":"LibTmux::X::new","signatures":[{"methodKind":"constructor","nativeSyntax":[{"end":7,"kind":"name","start":4},{"end":24,"kind":"parameter","parameter":0,"start":16}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub new($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":8,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-new"},{"apiScope":"exported","doc":{"summary":"Return the criterion or argument path, or undef when inapplicable."},"id":"LibTmux::X::path","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::path","qualifiedName":"LibTmux::X::path","signatures":[{"methodKind":"call","nativeSyntax":[{"end":8,"kind":"name","start":4}],"params":[],"raw":"sub path($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":11,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-path"},{"apiScope":"exported","doc":{"summary":"Return the received operand description, or undef."},"id":"LibTmux::X::received","kind":"method","modifiers":[],"name":"received","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::received","qualifiedName":"LibTmux::X::received","signatures":[{"methodKind":"call","nativeSyntax":[{"end":12,"kind":"name","start":4}],"params":[],"raw":"sub received($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":14,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-received"},{"apiScope":"exported","doc":{"summary":"Return a completed or bounded partial :obj:`LibTmux::CommandResult <LibTmux::CommandResult>`, or undef before process dispatch."},"id":"LibTmux::X::result","kind":"method","modifiers":[],"name":"result","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::result","qualifiedName":"LibTmux::X::result","signatures":[{"methodKind":"call","nativeSyntax":[{"end":10,"kind":"name","start":4}],"params":[],"raw":"sub result($self)","receiver":{"name":"self"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":17,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-result"},{"apiScope":"exported","doc":{"summary":"`throw(%details)` throws one exception object of the receiving class."},"id":"LibTmux::X::throw","kind":"method","modifiers":[],"name":"throw","package":"LibTmux","parent":"LibTmux::X","product":"core","publicId":"LibTmux::X::throw","qualifiedName":"LibTmux::X::throw","signatures":[{"methodKind":"call","nativeSyntax":[{"end":9,"kind":"name","start":4},{"end":26,"kind":"parameter","parameter":0,"start":18}],"params":[{"name":"details","variadic":"keyword"}],"raw":"sub throw($class, %details)","receiver":{"name":"class"}}],"source":{"extractedRevision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","file":"packages/core/lib/LibTmux/X.pm","line":9,"repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69"},"slug":"libtmux-x-throw"}]}
diff --git a/site/src/data/api/perl.paths.json b/site/src/data/api/perl.paths.json
index 714182aa9..cea623b95 100644
--- a/site/src/data/api/perl.paths.json
+++ b/site/src/data/api/perl.paths.json
@@ -1 +1 @@
-{"port":"perl","repo":"libtmux/libtmux-perl","revision":"d9fa7c5278d243c671a29cdb00e3a911ac651bfa","paths":[".github/CONTRIBUTING.md",".github/PERL.md",".github/WRITING.md",".github/dependabot.yml",".github/repository.json",".github/social-preview.png",".github/workflows/docs.yml",".github/workflows/scaffold.yml",".gitignore",".perltidyrc",".tool-versions","AGENTS.md","CLAUDE.md","LICENSE","Makefile","README.md","conformance/where-v1.json","cpanfile","docs/architecture.md","docs/assets/app-icon-1024-dark.png","docs/assets/app-icon-1024-light.png","docs/assets/apple-touch-icon-dark.png","docs/assets/apple-touch-icon-light.png","docs/assets/browserconfig-dark.xml","docs/assets/browserconfig.xml","docs/assets/favicon.ico","docs/assets/logo-1024.png","docs/assets/logo-128.png","docs/assets/logo-144.png","docs/assets/logo-152.png","docs/assets/logo-16.png","docs/assets/logo-167.png","docs/assets/logo-180.png","docs/assets/logo-192.png","docs/assets/logo-24.png","docs/assets/logo-256.png","docs/assets/logo-32.png","docs/assets/logo-384.png","docs/assets/logo-48.png","docs/assets/logo-512.png","docs/assets/logo-64.png","docs/assets/logo-96.png","docs/assets/logo.svg","docs/assets/maskable-192-dark.png","docs/assets/maskable-192-light.png","docs/assets/maskable-512-dark.png","docs/assets/maskable-512-light.png","docs/assets/mstile-150-dark.png","docs/assets/mstile-150-light.png","docs/assets/mstile-310-dark.png","docs/assets/mstile-310-light.png","docs/assets/opengraph-dark.jpg","docs/assets/opengraph-dark.png","docs/assets/opengraph-light.jpg","docs/assets/opengraph-light.png","docs/assets/safari-pinned-tab.svg","docs/assets/site-dark.webmanifest","docs/assets/site.webmanifest","docs/assets/social-square-dark.png","docs/assets/social-square-light.png","docs/assets/source.json","docs/assets/twitter-dark.png","docs/assets/twitter-light.png","docs/async.md","docs/behavior-inventory.json","docs/branding.md","docs/compatibility.md","docs/dev/adr/0001-core-async-workspace-architecture.md","docs/dev/adr/0002-reversible-native-getters.md","docs/dev/adr/0003-query-verification-diagnostics.md","docs/dev/adr/0004-atomic-async-child-exit.md","docs/dev/adr/0005-supervisor-signal-readiness.md","docs/dev/adr/index.md","docs/errors.md","docs/fields.md","docs/filtering.md","docs/graph.md","docs/installation.md","docs/orchestration.md","docs/python-behavior-inventory.json","docs/query-planning.md","docs/workspace.md","examples/README.md","examples/async-lifecycle.pl","examples/async.pl","examples/await.pl","examples/quickstart.pl","examples/selection.pl","examples/workspace.pl","packages/async/LICENSE","packages/async/MANIFEST.SKIP","packages/async/Makefile.PL","packages/async/README.md","packages/async/assets/logo.png","packages/async/assets/logo.svg","packages/async/assets/source.json","packages/async/cpanfile","packages/async/lib/LibTmux/Async.pm","packages/async/lib/LibTmux/Async/Server.pm","packages/async/lib/LibTmux/Async/Transport.pm","packages/async/lib/LibTmux/Async/X.pm","packages/async/t/integration/daemon-exit.t","packages/async/t/integration/parent-loss.t","packages/async/t/integration/tmux.t","packages/async/t/unit/server.t","packages/async/t/unit/signals.t","packages/async/t/unit/transport.t","packages/core/LICENSE","packages/core/MANIFEST.SKIP","packages/core/Makefile.PL","packages/core/README.md","packages/core/assets/logo.png","packages/core/assets/logo.svg","packages/core/assets/source.json","packages/core/cpanfile","packages/core/lib/LibTmux.pm","packages/core/lib/LibTmux/Client.pm","packages/core/lib/LibTmux/ClientSelection.pm","packages/core/lib/LibTmux/Codec.pm","packages/core/lib/LibTmux/CommandResult.pm","packages/core/lib/LibTmux/Entity.pm","packages/core/lib/LibTmux/Filter.pm","packages/core/lib/LibTmux/Operation.pm","packages/core/lib/LibTmux/Pane.pm","packages/core/lib/LibTmux/PaneSelection.pm","packages/core/lib/LibTmux/Platform/Linux.pm","packages/core/lib/LibTmux/ProcessJob.pm","packages/core/lib/LibTmux/QueryPlan.pm","packages/core/lib/LibTmux/Schema.pm","packages/core/lib/LibTmux/Selection.pm","packages/core/lib/LibTmux/Selection/Iterator.pm","packages/core/lib/LibTmux/Server.pm","packages/core/lib/LibTmux/Session.pm","packages/core/lib/LibTmux/SessionSelection.pm","packages/core/lib/LibTmux/Snapshot.pm","packages/core/lib/LibTmux/Transport.pm","packages/core/lib/LibTmux/Window.pm","packages/core/lib/LibTmux/WindowLink.pm","packages/core/lib/LibTmux/WindowLinkSelection.pm","packages/core/lib/LibTmux/WindowSelection.pm","packages/core/lib/LibTmux/X.pm","packages/core/lib/LibTmux/schema.json","packages/core/t/integration/codec.t","packages/core/t/integration/descriptors.t","packages/core/t/integration/fixture.t","packages/core/t/integration/getters.t","packages/core/t/integration/input-client.t","packages/core/t/integration/lifecycle.t","packages/core/t/integration/operands.t","packages/core/t/integration/operations.t","packages/core/t/integration/query-planning.t","packages/core/t/integration/tmux.t","packages/core/t/unit/availability.t","packages/core/t/unit/codec.t","packages/core/t/unit/descriptors.t","packages/core/t/unit/operation.t","packages/core/t/unit/query-verification.t","packages/core/t/unit/selection.t","packages/core/t/unit/server.t","packages/core/t/unit/transport.t","packages/workspace/LICENSE","packages/workspace/MANIFEST.SKIP","packages/workspace/Makefile.PL","packages/workspace/README.md","packages/workspace/assets/logo.png","packages/workspace/assets/logo.svg","packages/workspace/assets/source.json","packages/workspace/bin/libtmux-workspace","packages/workspace/cpanfile","packages/workspace/lib/LibTmux/Workspace.pm","packages/workspace/lib/LibTmux/Workspace/X.pm","packages/workspace/t/integration/creation-failure.t","packages/workspace/t/integration/generation.t","packages/workspace/t/integration/load.t","packages/workspace/t/unit/cleanup.t","packages/workspace/t/unit/config.t","scripts/async-wakeup/inject.c","scripts/async-wakeup/observe.pl","scripts/benchmark.pl","scripts/check-artifacts.pl","scripts/check-async-wakeup.py","scripts/check-pod.pl","scripts/check-snippets.pl","scripts/check-supervisor-wakeup.py","scripts/compatibility.py","scripts/conformance-reference.json","scripts/conformance.py","scripts/count-tmux-process.py","scripts/dependency-profile.pl","scripts/evidence.py","scripts/export-api.pl","scripts/filter-fixtures.pl","scripts/format.pl","scripts/generate.pl","scripts/installed-consumer.pl","scripts/inventory.py","scripts/lib/LibTmuxDev.pm","scripts/lib/LibTmuxFixture.pm","scripts/provision-consumer.py","scripts/pty-client.py","scripts/run-examples.pl","scripts/supervisor-wakeup/inject.c","scripts/supervisor-wakeup/observe.pl","scripts/tmux-lock.json","scripts/with-subreaper.py"]}
+{"port":"perl","repo":"libtmux/libtmux-perl","revision":"a1cab0324b600a5df6e34b92590b5c3bd8f79c69","paths":[".github/CONTRIBUTING.md",".github/PERL.md",".github/RELEASE.md",".github/WRITING.md",".github/dependabot.yml",".github/repository.json",".github/social-preview.png",".github/workflows/docs.yml",".github/workflows/release.yml",".github/workflows/scaffold.yml",".gitignore",".perltidyrc",".tool-versions","AGENTS.md","CLAUDE.md","LICENSE","Makefile","README.md","conformance/where-v1.json","cpanfile","docs/architecture.md","docs/assets/app-icon-1024-dark.png","docs/assets/app-icon-1024-light.png","docs/assets/apple-touch-icon-dark.png","docs/assets/apple-touch-icon-light.png","docs/assets/browserconfig-dark.xml","docs/assets/browserconfig.xml","docs/assets/favicon.ico","docs/assets/logo-1024.png","docs/assets/logo-128.png","docs/assets/logo-144.png","docs/assets/logo-152.png","docs/assets/logo-16.png","docs/assets/logo-167.png","docs/assets/logo-180.png","docs/assets/logo-192.png","docs/assets/logo-24.png","docs/assets/logo-256.png","docs/assets/logo-32.png","docs/assets/logo-384.png","docs/assets/logo-48.png","docs/assets/logo-512.png","docs/assets/logo-64.png","docs/assets/logo-96.png","docs/assets/logo.svg","docs/assets/maskable-192-dark.png","docs/assets/maskable-192-light.png","docs/assets/maskable-512-dark.png","docs/assets/maskable-512-light.png","docs/assets/mstile-150-dark.png","docs/assets/mstile-150-light.png","docs/assets/mstile-310-dark.png","docs/assets/mstile-310-light.png","docs/assets/opengraph-dark.jpg","docs/assets/opengraph-dark.png","docs/assets/opengraph-light.jpg","docs/assets/opengraph-light.png","docs/assets/safari-pinned-tab.svg","docs/assets/site-dark.webmanifest","docs/assets/site.webmanifest","docs/assets/social-square-dark.png","docs/assets/social-square-light.png","docs/assets/source.json","docs/assets/twitter-dark.png","docs/assets/twitter-light.png","docs/async.md","docs/behavior-inventory.json","docs/branding.md","docs/compatibility.md","docs/dev/adr/0001-core-async-workspace-architecture.md","docs/dev/adr/0002-reversible-native-getters.md","docs/dev/adr/0003-query-verification-diagnostics.md","docs/dev/adr/0004-atomic-async-child-exit.md","docs/dev/adr/0005-supervisor-signal-readiness.md","docs/dev/adr/index.md","docs/errors.md","docs/fields.md","docs/filtering.md","docs/graph.md","docs/installation.md","docs/orchestration.md","docs/python-behavior-inventory.json","docs/query-planning.md","docs/workspace.md","examples/README.md","examples/async-lifecycle.pl","examples/async.pl","examples/await.pl","examples/quickstart.pl","examples/selection.pl","examples/workspace.pl","packages/async/Changes","packages/async/LICENSE","packages/async/MANIFEST.SKIP","packages/async/Makefile.PL","packages/async/README.md","packages/async/assets/logo.png","packages/async/assets/logo.svg","packages/async/assets/source.json","packages/async/cpanfile","packages/async/examples/concurrent.pl","packages/async/lib/LibTmux/Async.pm","packages/async/lib/LibTmux/Async/Server.pm","packages/async/lib/LibTmux/Async/Transport.pm","packages/async/lib/LibTmux/Async/X.pm","packages/async/t/integration/daemon-exit.t","packages/async/t/integration/parent-loss.t","packages/async/t/integration/tmux.t","packages/async/t/unit/server.t","packages/async/t/unit/signals.t","packages/async/t/unit/transport.t","packages/core/Changes","packages/core/LICENSE","packages/core/MANIFEST.SKIP","packages/core/Makefile.PL","packages/core/README.md","packages/core/assets/logo.png","packages/core/assets/logo.svg","packages/core/assets/source.json","packages/core/cpanfile","packages/core/examples/filters.pl","packages/core/examples/quickstart.pl","packages/core/examples/workflow.pl","packages/core/lib/LibTmux.pm","packages/core/lib/LibTmux/Client.pm","packages/core/lib/LibTmux/ClientSelection.pm","packages/core/lib/LibTmux/Codec.pm","packages/core/lib/LibTmux/CommandResult.pm","packages/core/lib/LibTmux/Entity.pm","packages/core/lib/LibTmux/Filter.pm","packages/core/lib/LibTmux/Operation.pm","packages/core/lib/LibTmux/Pane.pm","packages/core/lib/LibTmux/PaneSelection.pm","packages/core/lib/LibTmux/Platform/Linux.pm","packages/core/lib/LibTmux/ProcessJob.pm","packages/core/lib/LibTmux/QueryPlan.pm","packages/core/lib/LibTmux/Schema.pm","packages/core/lib/LibTmux/Selection.pm","packages/core/lib/LibTmux/Selection/Iterator.pm","packages/core/lib/LibTmux/Server.pm","packages/core/lib/LibTmux/Session.pm","packages/core/lib/LibTmux/SessionSelection.pm","packages/core/lib/LibTmux/Snapshot.pm","packages/core/lib/LibTmux/Transport.pm","packages/core/lib/LibTmux/Window.pm","packages/core/lib/LibTmux/WindowLink.pm","packages/core/lib/LibTmux/WindowLinkSelection.pm","packages/core/lib/LibTmux/WindowSelection.pm","packages/core/lib/LibTmux/X.pm","packages/core/lib/LibTmux/schema.json","packages/core/t/integration/codec.t","packages/core/t/integration/descriptors.t","packages/core/t/integration/fixture.t","packages/core/t/integration/getters.t","packages/core/t/integration/input-client.t","packages/core/t/integration/lifecycle.t","packages/core/t/integration/operands.t","packages/core/t/integration/operations.t","packages/core/t/integration/query-planning.t","packages/core/t/integration/tmux.t","packages/core/t/unit/availability.t","packages/core/t/unit/codec.t","packages/core/t/unit/descriptors.t","packages/core/t/unit/operation.t","packages/core/t/unit/query-verification.t","packages/core/t/unit/selection.t","packages/core/t/unit/server.t","packages/core/t/unit/transport.t","packages/workspace/Changes","packages/workspace/LICENSE","packages/workspace/MANIFEST.SKIP","packages/workspace/Makefile.PL","packages/workspace/README.md","packages/workspace/assets/logo.png","packages/workspace/assets/logo.svg","packages/workspace/assets/source.json","packages/workspace/bin/libtmux-workspace","packages/workspace/cpanfile","packages/workspace/examples/load.pl","packages/workspace/examples/workspace.json","packages/workspace/lib/LibTmux/Workspace.pm","packages/workspace/lib/LibTmux/Workspace/X.pm","packages/workspace/t/integration/creation-failure.t","packages/workspace/t/integration/generation.t","packages/workspace/t/integration/load.t","packages/workspace/t/unit/cleanup.t","packages/workspace/t/unit/config.t","scripts/async-wakeup/inject.c","scripts/async-wakeup/observe.pl","scripts/benchmark.pl","scripts/check-artifacts.pl","scripts/check-async-wakeup.py","scripts/check-pod.pl","scripts/check-snippets.pl","scripts/check-supervisor-wakeup.py","scripts/compatibility.py","scripts/conformance-reference.json","scripts/conformance.py","scripts/count-tmux-process.py","scripts/dependency-profile.pl","scripts/evidence.py","scripts/export-api.pl","scripts/filter-fixtures.pl","scripts/format.pl","scripts/generate.pl","scripts/installed-consumer.pl","scripts/inventory.py","scripts/lib/LibTmuxDev.pm","scripts/lib/LibTmuxFixture.pm","scripts/lib/LibTmuxRelease.pm","scripts/provision-consumer.py","scripts/pty-client.py","scripts/release.pl","scripts/release/t/upload.t","scripts/run-examples.pl","scripts/supervisor-wakeup/inject.c","scripts/supervisor-wakeup/observe.pl","scripts/t/release.t","scripts/tmux-lock.json","scripts/with-subreaper.py"]}
diff --git a/site/src/data/api/raku.json b/site/src/data/api/raku.json
new file mode 100644
index 000000000..e232d3a58
--- /dev/null
+++ b/site/src/data/api/raku.json
@@ -0,0 +1 @@
+{"port":"raku","repo":"libtmux/libtmux-raku","revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","extractor":"Rakudo RakuAST and RakuDoc/v1","symbols":[{"apiScope":"exported","doc":{"body":"# LibTmux\n\nTyped tmux snapshots, local selections and explicit commands for Raku programs.\n\n\n\n# Create a session and split a pane\n\n:obj:`Server <LibTmux::Server>` starts and owns a private daemon. Split the first pane,\nset pane titles, then capture the new state. Both panes run ` cat ` as an echo\nprocess. ` LEAVE ` closes the owner on normal or exceptional exit.\n\n\n\n```raku\nuse LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n```\n\nThe program prints ` editor: 2 panes `. The earlier snapshot retains\none pane. ` .ref ` constructs an explicit command target; mutation does not change\nan earlier observation. ` snapshot ` performs I/O, while reading a captured field\nor relationship stays local.\n\n\n\n# Follow the captured graph\n\nA :obj:`Snapshot <LibTmux::Model::Snapshot>` contains sessions, session groups, physical\nwindows, window links, panes, clients and buffer metadata. A physical window can\nappear at several indexes, including twice in the same session. Its\n` WindowLink ` owns the session-relative index and active state. ` windows ` and\n` panes ` enumerate physical identities once; ` window-links ` preserves placements.\n\nA pane's ` window ` and a window's ` panes ` resolve against the retained graph.\nKeeping an observation after closing its acquisition owner remains useful:\nfield reads, relationship traversal and selection operations make no tmux calls.\nUse ` .ref.inspect ` or a new snapshot when fresh information is needed.\nReferences include daemon incarnation evidence, so a replacement daemon does\nnot inherit an old pane reference merely by reusing its ID.\n\n\n\n# Query captured values\n\nCombine validated query data with native Raku predicates and transformations:\n\n\n\n```raku\nuse v6.d;\nuse LibTmux;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<work>,\n        :width(160), :height(40), :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n\n    my $editor = $server.snapshot.panes.single.ref;\n    my $tests = $editor.split(:horizontal, :shell-command('exec cat'));\n    my $logs = $tests.split(:shell-command('exec cat'));\n    $editor.set-title('editor');\n    $tests.set-title('tests');\n    $logs.set-title('logs');\n\n    my $snapshot = $server.snapshot;\n    my @wide := $snapshot.panes.where(%(width => %(gte => 60)));\n    my $selected = @wide.filter(*.title eq 'editor').single;\n    say \"Wide pane: {$selected.title}\";\n\n    my @others = $snapshot.panes.grep(*.id ne $selected.id).map(*.title).sort;\n    say 'Other panes: ' ~ @others.join(', ');\n}\n```\n\nIt prints ` Wide pane: editor ` and\n` Other panes: logs, tests `.\n\nBinding with ` := ` preserves a typed selection. Array assignment materializes\nordinary Raku values; scalar assignment itemizes the collection. ` where `\nvalidates fields and operators even on an empty selection. ` filter ` evaluates a\ncallback eagerly and returns the same entity selection type. ` grep `, including\n` :k `, ` :kv ` and ` :p `, retains its native ` Seq ` contract. ` map `, ` sort `,\n` first ` and junction operations also retain ordinary Raku behavior. Mapping\npanes to titles does not produce a pane selection of strings.\n\nUse ` single ` for exactly one member and ` single-or-nil ` for zero or one;\nmultiple matches throw :obj:`Cardinality <X::LibTmux::Cardinality>`. ` one ` remains a\njunction. A directly returned ` Failure ` from a ` filter ` callback throws its\nwrapped exception before Boolean coercion.\n\nCompile reusable criteria with :obj:`Filter <LibTmux::Query::Filter>`. Its ` ACCEPTS `\nmethod permits native matching, and ` to-json `/` from-json ` preserve the bounded\nportable data grammar. Closures, regexes and junctions remain local Raku\nmatchers. Data equality follows field types; it does not use generic smartmatch.\nRelations use ` some `, ` every `, ` none `, ` is ` and ` is-not `. An unloaded\nrelation raises :obj:`MissingData <X::LibTmux::MissingData>` instead of behaving like\nan empty relation.\n\nFor explicit live acquisition, ` query-panes ` accepts ` where ` and a pushdown\npolicy. ` auto ` pushes proven exact restrictions and evaluates residual work\nlocally; ` never ` evaluates locally after acquisition; ` require ` refuses an\ninexact translation. ` explain-panes ` describes projections, scope, pushed\nconditions and residual work. Arbitrary callbacks are not translated to tmux.\n\n\n\n# Choose an operation from capabilities\n\nCapabilities describe the observed daemon separately from the client executable.\nAsk ` supports ` before offering a newer operation, or use ` require ` to obtain a\ntyped refusal with its reason. This program creates an empty ` status ` pane\nas a floating pane when supported and a tiled split otherwise:\n\n\n\n```raku\nuse v6.d;\nuse LibTmux;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<work>,\n        :width(120), :height(36), :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n\n    my $snapshot = $server.snapshot;\n    my $main = $snapshot.panes.single.ref;\n    my $floating = $snapshot.capabilities.supports('pane-floating');\n    my $auxiliary = $floating\n        ?? $main.new-floating(:width(40), :height(12), :x(2), :y(2), :empty)\n        !! $main.split(:horizontal, :empty);\n    $auxiliary.set-title('status');\n\n    my $after = $server.snapshot;\n    die 'The auxiliary pane was not captured' unless $after.panes.elems == 2;\n    say 'Status pane: ' ~ ($floating ?? 'floating' !! 'tiled');\n    say $after.panes.where(%(id => $auxiliary.id)).single.title;\n}\n```\n\nThe selected placement and ` status ` are printed. An empty pane can\nhave no child PID; its ` pid ` is then null rather than a fabricated integer.\n` state('pid') ` distinguishes known null from a field that was not acquired.\nUnknown release profiles are refused conservatively. Field, codec, layout and\ncommand decisions come from the same packaged catalogue.\n\n\n\n# React to terminal output\n\nSynchronous acquisition returns a snapshot or selection. An ` -async ` method\nreturns a ` Promise ` resolving to that result. A\n:obj:`ControlConnection <LibTmux::Control::Connection>` owns one persistent client;\nits event ` Supply ` is shared by its subscribers. Native ` react ` and ` whenever `\ncan consume the output without polling:\n\n\n\n```raku\nuse v6.d;\nuse LibTmux;\nuse LibTmux::Control;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<output>, :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n    my $snapshot = await $server.snapshot-async;\n    my $pane = $snapshot.panes.single.ref;\n    my $connection = await $server.open-control-async(:session-id($snapshot.sessions.single.id));\n    LEAVE $connection.close if $connection.defined;\n\n    my $message = 'hello from Raku';\n    my $received = '';\n    react {\n        whenever $connection.events.grep(PaneOutput) -> $event {\n            if $event.pane-id eq $pane.id {\n                $received ~= $event.data.decode('utf8-c8');\n                die 'Pane output exceeded its bound' if $received.chars > 65536;\n                done if $received.contains($message);\n            }\n        }\n        whenever start { $pane.send-text($message); $pane.send-keys('Enter') } { }\n        whenever Promise.in(2) { die 'Pane output timed out' }\n    }\n\n    die 'The captured screen did not contain the message'\n        unless $pane.capture.decode('utf8').contains($message);\n    say $message;\n    say 'Screen capture confirmed';\n}\n```\n\nIt prints ` hello from Raku ` and ` Screen capture confirmed `.\nThe pane runs ` cat ` as an echo process. Subscribing precedes input.\nReceived pane bytes establish the screen-capture\nprecondition; the deadline bounds the wait. ` send-text ` never appends Enter.\nOutput remains bytes until an explicit decoder is selected, so fragmented and\ninvalid UTF-8 remains available. Unknown notification types retain their raw\nrepresentation.\n\nConnections need explicit close. Cancellation terminates and joins owned client\nwork, but does not undo commands that the daemon already executed. Reconnection\nrequires a fresh observation; event delivery does not imply a complete current\ngraph. :obj:`Attachment <LibTmux::Attachment>` is a separate terminal client owner.\n\n\n\n# Recover from partial completion\n\n:obj:`Batch <LibTmux::Batch::Batch>` reports each operation's completion scope and\noutcome. The\n[batch recovery program](https://github.com/libtmux/libtmux-raku/blob/master/examples/batch-recovery.raku)\nchecks ` Complete `, ` Failed ` and ` Skipped `, verifies the successful first\neffect, then removes it explicitly. Acknowledgement alone does not prove an\napplication effect. A failed batch offers no rollback guarantee.\n\nThe\n[session workflow program](https://github.com/libtmux/libtmux-raku/blob/master/examples/session-workflow.raku)\ncombines creation, a control-output subscription, screen capture, local\nfiltering and an explained source query in one checked lifecycle.\n\n\n\n# Ownership and operational errors\n\n` Server.start ` owns its private daemon. ` Server.new ` configures a borrowed\nendpoint; closing that facade leaves the daemon running. Both need explicit\nclose. A connection or terminal attachment has its own lifetime and must also\nbe closed. An observation retains values and the captured graph, not a live\nacquisition process.\n\nCommands pass an argument vector. Literal pane text, explicit key presses,\nFORMAT expressions, tmux command templates and deliberate shell commands have\nseparate entry points. Operational errors retain typed context and captured\nbytes. Optional lookup absence never disguises a failed command. Fields retain\nknown null, false, zero, empty text, unsupported, unavailable and unloaded data\nas distinct states.","summary":""},"id":"LibTmux","kind":"module","modifiers":[],"name":"LibTmux","package":"LibTmux","product":"core","publicId":"LibTmux","signatures":[],"source":{"file":"lib/LibTmux.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux"},{"apiScope":"exported","doc":{"body":"# Explicit interactive terminal ownership\n\nspawn binds stdin and stdout to the supplied open terminal handle. It never\ninherits the calling program's terminal implicitly. The caller owns that handle\nand its terminal output; Attachment owns the child and bounded binary stderr.\nclose stops and reaps only that child, leaves the handle open, and does not stop\nthe daemon or other clients. Cancellation applies to startup, not the later\ninteractive lifetime. Use close to end that lifetime.\n\nspawn proves OS process creation only. state starts as AttachmentPending;\ninspect-client makes one explicit listing and records AttachmentAttached when\nthe owned PID is present. Child exit independently records AttachmentExited.\nThere is no polling loop or implicit readiness claim. An event from a separately\nowned control connection may supply application-specific readiness evidence.\n\nThe initial session read checks Linux daemon identity, and the attach command\nruns in a PID/start-time fence. The Engine's documented same-PID/same-second\nreplacement and normal builtin-dispatch assumptions also apply here. An exit\nResult describes the tmux client process, not the lifetime of its session.","summary":""},"id":"LibTmux::Attachment","kind":"class","modifiers":[],"name":"Attachment","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Attachment","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment"},{"apiScope":"exported","doc":{"body":"Refuse copying an owner, which would duplicate cleanup authority over one child.","summary":"Refuse copying an owner, which would duplicate cleanup authority over one child."},"id":"LibTmux::Attachment.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":52,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-clone"},{"apiScope":"exported","doc":{"body":"Terminate and reap only this child. The caller's terminal handle stays open.","summary":"Terminate and reap only this child. The caller's terminal handle stays open."},"id":"LibTmux::Attachment.close","kind":"method","modifiers":[],"name":"close","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.close","signatures":[{"params":[],"raw":"method close(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":220,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-close"},{"apiScope":"exported","doc":{"body":"Share idempotent child cleanup; failure to reap breaks the returned Promise.","summary":"Share idempotent child cleanup; failure to reap breaks the returned Promise."},"id":"LibTmux::Attachment.close-async","kind":"method","modifiers":[],"name":"close-async","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.close-async","signatures":[{"params":[],"raw":"method close-async(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close-async","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":222,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-close-async"},{"apiScope":"exported","doc":{"body":"Socket and executable configuration used for this child and explicit inspections.","summary":"Socket and executable configuration used for this child and explicit inspections."},"id":"LibTmux::Attachment.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-attachment-endpoint"},{"apiScope":"exported","doc":{"body":"Daemon identity captured before attachment; a replacement daemon is rejected.","summary":"Daemon identity captured before attachment; a replacement daemon is rejected."},"id":"LibTmux::Attachment.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Incarnation:D","slug":"libtmux-attachment-incarnation"},{"apiScope":"exported","doc":{"body":"Perform one explicit listing. Nil means no matching attached client was observed.","summary":"Perform one explicit listing. Nil means no matching attached client was observed."},"id":"LibTmux::Attachment.inspect-client","kind":"method","modifiers":[],"name":"inspect-client","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.inspect-client","signatures":[{"params":[{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true,"type":"Positive:D"}],"raw":"method inspect-client(Positive:D :$timeout-ms = 10_000 --> Mu)","references":[{"end":32,"start":22,"target":"LibTmux::Types::Positive"}],"returns":"Mu","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect-client","declaration":true},{"text":"("},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms = 10_000 --> Mu)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":196,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-inspect-client"},{"apiScope":"exported","doc":{"body":"Retained stderr byte limit; exceeding it terminates the child and fails when-exited.","summary":"Retained stderr byte limit; exceeding it terminates the child and fails when-exited."},"id":"LibTmux::Attachment.max-stderr-bytes","kind":"property","modifiers":[],"name":"max-stderr-bytes","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.max-stderr-bytes","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-attachment-max-stderr-bytes"},{"apiScope":"exported","doc":{"body":"Construction requires spawn so an unstarted process owner cannot escape.","summary":"Construction requires spawn so an unstarted process owner cannot escape."},"id":"LibTmux::Attachment.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":50,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-new"},{"apiScope":"exported","doc":{"body":"Owned OS child identity; a nonzero PID does not establish attachment readiness.","summary":"Owned OS child identity; a nonzero PID does not establish attachment readiness."},"id":"LibTmux::Attachment.pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.pid","signatures":[{"params":[],"raw":"method pid(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pid","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":189,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-pid"},{"apiScope":"exported","doc":{"body":"Initial session ID; later interactive switching does not change this value.","summary":"Initial session ID; later interactive switching does not change this value."},"id":"LibTmux::Attachment.session","kind":"property","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.session","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":29,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SessionId:D","slug":"libtmux-attachment-session"},{"apiScope":"exported","doc":{"body":"Spawn a tmux client on a supplied terminal. This does not prove attachment.","summary":"Spawn a tmux client on a supplied terminal. This does not prove attachment."},"id":"LibTmux::Attachment.spawn","kind":"method","modifiers":[],"name":"spawn","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.spawn","signatures":[{"params":[{"keywordOnly":true,"name":"$endpoint","optional":false,"type":"Endpoint:D"},{"keywordOnly":true,"name":"$incarnation","optional":false,"type":"Incarnation:D"},{"keywordOnly":true,"name":"$session","optional":false,"type":"SessionId:D"},{"keywordOnly":true,"name":"$terminal","optional":false,"type":"IO::Handle:D"},{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true,"type":"Positive:D"},{"default":"64 * 1024","keywordOnly":true,"name":"$max-stderr-bytes","optional":true,"type":"Positive:D"},{"default":"False","keywordOnly":true,"name":"$read-only","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$detach-others","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$update-environment","optional":true,"type":"Bool:D"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method spawn(Endpoint:D :$endpoint!, Incarnation:D :$incarnation!,\n             SessionId:D :$session!, IO::Handle:D :$terminal!,\n             Positive:D :$timeout-ms = 10_000, Positive:D :$max-stderr-bytes = 64 * 1024,\n             Bool:D :$read-only = False, Bool:D :$detach-others = False,\n             Bool:D :$update-environment = False,\n             Cancellation :$cancel = Cancellation --> LibTmux::Attachment:D)","references":[{"end":23,"start":13,"target":"LibTmux::Engine::Endpoint"},{"end":50,"start":37,"target":"LibTmux::Engine::Incarnation"},{"end":91,"start":80,"target":"LibTmux::Types::SessionId"},{"end":153,"start":143,"target":"LibTmux::Types::Positive"},{"end":187,"start":177,"target":"LibTmux::Types::Positive"},{"end":368,"start":356,"target":"LibTmux::Transport::Cancellation"},{"end":392,"start":380,"target":"LibTmux::Transport::Cancellation"},{"end":418,"start":397,"target":"LibTmux::Attachment"}],"returns":"LibTmux::Attachment:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"spawn","declaration":true},{"text":"("},{"text":"Endpoint:D","target":"LibTmux::Engine::Endpoint"},{"text":" :$endpoint!, "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":" :$incarnation!,\n             "},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" :$session!, IO::Handle:D :$terminal!,\n             "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms = 10_000, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$max-stderr-bytes = 64 * 1024,\n             Bool:D :$read-only = False, Bool:D :$detach-others = False,\n             Bool:D :$update-environment = False,\n             "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"LibTmux::Attachment:D","target":"LibTmux::Attachment"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-spawn"},{"apiScope":"exported","doc":{"body":"Last explicit attachment observation, or the independently observed process exit.","summary":"Last explicit attachment observation, or the independently observed process exit."},"id":"LibTmux::Attachment.state","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.state","signatures":[{"params":[],"raw":"method state(--> AttachmentState:D)","references":[{"end":34,"start":17,"target":"LibTmux::Attachment::AttachmentState"}],"returns":"AttachmentState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(--> "},{"text":"AttachmentState:D","target":"LibTmux::Attachment::AttachmentState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":191,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-state"},{"apiScope":"exported","doc":{"body":"Resolve after the child exits and stderr is drained, preserving its exit status.","summary":"Resolve after the child exits and stderr is drained, preserving its exit status."},"id":"LibTmux::Attachment.when-exited","kind":"method","modifiers":[],"name":"when-exited","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment.when-exited","signatures":[{"params":[],"raw":"method when-exited(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"when-exited","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":193,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-when-exited"},{"apiScope":"exported","doc":{"body":"State established by process completion or the most recent explicit inspection.","summary":"State established by process completion or the most recent explicit inspection."},"id":"LibTmux::Attachment::AttachmentState","kind":"enum","modifiers":[],"name":"AttachmentState","package":"LibTmux","parent":"LibTmux::Attachment","product":"core","publicId":"LibTmux::Attachment::AttachmentState","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-attachment-attachmentstate"},{"apiScope":"exported","doc":{"body":"State established by process completion or the most recent explicit inspection.","summary":"State established by process completion or the most recent explicit inspection."},"id":"LibTmux::Attachment::AttachmentState.AttachmentAttached","kind":"constant","modifiers":[],"name":"AttachmentAttached","package":"LibTmux","parent":"LibTmux::Attachment::AttachmentState","product":"core","publicId":"LibTmux::Attachment::AttachmentState.AttachmentAttached","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"1","slug":"libtmux-attachment-attachmentstate-attachmentattached"},{"apiScope":"exported","doc":{"body":"State established by process completion or the most recent explicit inspection.","summary":"State established by process completion or the most recent explicit inspection."},"id":"LibTmux::Attachment::AttachmentState.AttachmentExited","kind":"constant","modifiers":[],"name":"AttachmentExited","package":"LibTmux","parent":"LibTmux::Attachment::AttachmentState","product":"core","publicId":"LibTmux::Attachment::AttachmentState.AttachmentExited","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"2","slug":"libtmux-attachment-attachmentstate-attachmentexited"},{"apiScope":"exported","doc":{"body":"State established by process completion or the most recent explicit inspection.","summary":"State established by process completion or the most recent explicit inspection."},"id":"LibTmux::Attachment::AttachmentState.AttachmentPending","kind":"constant","modifiers":[],"name":"AttachmentPending","package":"LibTmux","parent":"LibTmux::Attachment::AttachmentState","product":"core","publicId":"LibTmux::Attachment::AttachmentState.AttachmentPending","signatures":[],"source":{"file":"lib/LibTmux/Attachment.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"0","slug":"libtmux-attachment-attachmentstate-attachmentpending"},{"apiScope":"exported","doc":{"body":"# Partial outcomes, not transactions\n\nOperation requires either acknowledgement-only or a Promise of Evidence. In\ncommand scope, Complete means a successful command acknowledgement; it does not\nprove an asynchronous external effect. In effect scope, Complete additionally\nrequires matching named Evidence with satisfied=True. Evidence is supplied by\nthe caller, who must arm and correlate its operation-specific observer before\ndispatch. A name match is not proof of causation. No caller callback runs inside\nthe batch. Its deadline bounds waiting, not the caller's independent work.\nEvidence Promises are one-shot: rerunning effect-aware commands requires newly\narmed evidence, rather than treating an old observation as a new completion.\n\nThe immutable Batch captures finite membership, preserving order and rejecting\nduplicate names. Empty membership is a no-op. run/run-async accept an existing\nRuntime, Control connection or compatible CommandExecutor and never close it.\nAdapters must validate without effects, honor absolute deadlines and cancellation,\nsettle their execution Promises with Receipt values, and preserve effect certainty\nin typed errors.\nAll operations share one absolute deadline. A supplied ` :deadline(Instant) `\ncan shorten the local ` timeout-ms ` budget; it never extends that budget. The\nsame Instant is passed to every command and retained in the report. An already\nexpired deadline skips dispatch. The executor may use a shorter local limit. Cleanup retains\nthe executor's own separate bounds. Cancelling a dispatched Control request can\nclose that connection according to its documented delivery contract.\n\nEvery position receives an OperationResult. Failure stops subsequent dispatch\nby default; on-error=continue attempts remaining operations while time and\ncancellation permit. Never-dispatched suffixes are Skipped. A timed out or lost\nin-flight effect is Indeterminate, even if acknowledgement was received. The\noriginal exception and its outcome remain available through error/error-outcome.\nNo rollback is attempted or promised, and reports retain no executor owner.\n\noutput-budget-bytes defaults to 8 MiB. After each operation, Batch counts receipt\noutput and Command exception stdout/stderr, following shared Command causes only\nonce. Reaching or exceeding the threshold stops further dispatch even under\non-error=continue. The complete threshold-crossing receipt/error is retained and\nthe undispatched suffix is Skipped. This is an admission threshold: retained\noutput can reach the budget plus one executor-bounded response. It is not a hard\nRSS cap; object overhead, arbitrary adapter/evidence exceptions and independent\ncaller-owned tasks remain outside that bound. Such adapters must accurately\nreport Receipt.output-bytes and bound their own responses.","summary":""},"id":"LibTmux::Batch","kind":"module","modifiers":[],"name":"Batch","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Batch","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch"},{"apiScope":"exported","doc":{"body":"A finite replayable sequence of explicit commands, without transaction semantics.","summary":"A finite replayable sequence of explicit commands, without transaction semantics."},"id":"LibTmux::Batch::Batch","kind":"class","modifiers":[],"name":"Batch","package":"LibTmux","parent":"LibTmux::Batch","product":"core","publicId":"LibTmux::Batch::Batch","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":206,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-batch"},{"apiScope":"exported","doc":{"body":"Revalidate changed membership or limits; unchanged evidence is not rearmed.","summary":"Revalidate changed membership or limits; unchanged evidence is not rearmed."},"id":"LibTmux::Batch::Batch.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Batch:D)","references":[{"end":34,"start":27,"target":"LibTmux::Batch::Batch"}],"returns":"Batch:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Batch:D","target":"LibTmux::Batch::Batch"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":248,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-batch-clone"},{"apiScope":"exported","doc":{"body":"Maximum sum of encoded Invocation source bytes before executor guard encoding.","summary":"Maximum sum of encoded Invocation source bytes before executor guard encoding."},"id":"LibTmux::Batch::Batch.max-command-bytes","kind":"property","modifiers":[],"name":"max-command-bytes","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.max-command-bytes","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":212,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-batch-batch-max-command-bytes"},{"apiScope":"exported","doc":{"body":"Maximum admitted operation count, enforced during incremental traversal.","summary":"Maximum admitted operation count, enforced during incremental traversal."},"id":"LibTmux::Batch::Batch.max-operations","kind":"property","modifiers":[],"name":"max-operations","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.max-operations","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":210,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-batch-batch-max-operations"},{"apiScope":"exported","doc":{"body":"Copy finite membership and validate all size/name limits without I/O.","summary":"Copy finite membership and validate all size/name limits without I/O."},"id":"LibTmux::Batch::Batch.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.new","signatures":[{"params":[{"keywordOnly":true,"name":"$operations","optional":false,"type":"Mu"},{"default":"256","keywordOnly":true,"name":"$max-operations","optional":true,"type":"Mu"},{"default":"1024 * 1024","keywordOnly":true,"name":"$max-command-bytes","optional":true,"type":"Mu"},{"default":"8 * 1024 * 1024","keywordOnly":true,"name":"$output-budget-bytes","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method new(Mu :$operations!, Mu :$max-operations = 256,\n               Mu :$max-command-bytes = 1024 * 1024,\n               Mu :$output-budget-bytes = 8 * 1024 * 1024, *%unknown)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(Mu :$operations!, Mu :$max-operations = 256,\n               Mu :$max-command-bytes = 1024 * 1024,\n               Mu :$output-budget-bytes = 8 * 1024 * 1024, *%unknown)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":217,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-batch-new"},{"apiScope":"exported","doc":{"body":"Captured eager Operation membership; replay preserves this order.","summary":"Captured eager Operation membership; replay preserves this order."},"id":"LibTmux::Batch::Batch.operations","kind":"property","modifiers":[],"name":"operations","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.operations","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":208,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-batch-batch-operations"},{"apiScope":"exported","doc":{"body":"Stop further dispatch once retained output reaches this byte threshold.","summary":"Stop further dispatch once retained output reaches this byte threshold."},"id":"LibTmux::Batch::Batch.output-budget-bytes","kind":"property","modifiers":[],"name":"output-budget-bytes","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.output-budget-bytes","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":214,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-batch-batch-output-budget-bytes"},{"apiScope":"exported","doc":{"body":"Run sequentially through a caller-owned executor; collect every position.","summary":"Run sequentially through a caller-owned executor; collect every position."},"id":"LibTmux::Batch::Batch.run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.run","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method run(*%options --> Report:D)","references":[{"end":33,"start":25,"target":"LibTmux::Batch::Report"}],"returns":"Report:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run","declaration":true},{"text":"(*%options --> "},{"text":"Report:D","target":"LibTmux::Batch::Report"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":259,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-batch-run"},{"apiScope":"exported","doc":{"body":"Share one deadline across commands and evidence; never invoke caller callbacks.","summary":"Share one deadline across commands and evidence; never invoke caller callbacks."},"id":"LibTmux::Batch::Batch.run-async","kind":"method","modifiers":[],"name":"run-async","package":"LibTmux","parent":"LibTmux::Batch::Batch","product":"core","publicId":"LibTmux::Batch::Batch.run-async","signatures":[{"params":[{"keywordOnly":true,"name":"$executor","optional":false,"type":"Mu"},{"keywordOnly":true,"name":"$incarnation","optional":false,"type":"Mu"},{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true,"type":"Mu"},{"default":"Instant","keywordOnly":true,"name":"$requested-deadline","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Mu"},{"default":"'stop'","keywordOnly":true,"name":"$on-error","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method run-async(Mu :$executor!, Mu :$incarnation!, Mu :$timeout-ms = 10_000,\n                     Mu :deadline($requested-deadline) = Instant,\n                     Mu :$cancel = Cancellation, Mu :$on-error = 'stop',\n                     *%unknown --> Promise:D)","references":[{"end":191,"start":179,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run-async","declaration":true},{"text":"(Mu :$executor!, Mu :$incarnation!, Mu :$timeout-ms = 10_000,\n                     Mu :deadline($requested-deadline) = Instant,\n                     Mu :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":", Mu :$on-error = 'stop',\n                     *%unknown --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":262,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-batch-run-async"},{"apiScope":"exported","doc":{"body":"Caller-supplied evidence for one named operation, not a command acknowledgement.","summary":"Caller-supplied evidence for one named operation, not a command acknowledgement."},"id":"LibTmux::Batch::Evidence","kind":"class","modifiers":[],"name":"Evidence","package":"LibTmux","parent":"LibTmux::Batch","product":"core","publicId":"LibTmux::Batch::Evidence","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-evidence"},{"apiScope":"exported","doc":{"body":"Validate replacement observation data; cloning does not reobserve an effect.","summary":"Validate replacement observation data; cloning does not reobserve an effect."},"id":"LibTmux::Batch::Evidence.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Batch::Evidence","product":"core","publicId":"LibTmux::Batch::Evidence.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Evidence:D)","references":[{"end":37,"start":27,"target":"LibTmux::Batch::Evidence"}],"returns":"Evidence:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Evidence:D","target":"LibTmux::Batch::Evidence"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":42,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-evidence-clone"},{"apiScope":"exported","doc":{"body":"Caller description of the observed postcondition, limited to 4096 characters.","summary":"Caller description of the observed postcondition, limited to 4096 characters."},"id":"LibTmux::Batch::Evidence.description","kind":"property","modifiers":[],"name":"description","package":"LibTmux","parent":"LibTmux::Batch::Evidence","product":"core","publicId":"LibTmux::Batch::Evidence.description","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-evidence-description"},{"apiScope":"exported","doc":{"body":"Unique batch operation name this observation was armed to verify.","summary":"Unique batch operation name this observation was armed to verify."},"id":"LibTmux::Batch::Evidence.operation","kind":"property","modifiers":[],"name":"operation","package":"LibTmux","parent":"LibTmux::Batch::Evidence","product":"core","publicId":"LibTmux::Batch::Evidence.operation","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":29,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-evidence-operation"},{"apiScope":"exported","doc":{"body":"Whether that postcondition held; False records a failed effect contract.","summary":"Whether that postcondition held; False records a failed effect contract."},"id":"LibTmux::Batch::Evidence.satisfied","kind":"property","modifiers":[],"name":"satisfied","package":"LibTmux","parent":"LibTmux::Batch::Evidence","product":"core","publicId":"LibTmux::Batch::Evidence.satisfied","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-batch-evidence-satisfied"},{"apiScope":"exported","doc":{"body":"One immutable command and an explicit completion contract.","summary":"One immutable command and an explicit completion contract."},"id":"LibTmux::Batch::Operation","kind":"class","modifiers":[],"name":"Operation","package":"LibTmux","parent":"LibTmux::Batch","product":"core","publicId":"LibTmux::Batch::Operation","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operation"},{"apiScope":"exported","doc":{"body":"Accept command acknowledgement as completion without external effect proof.","summary":"Accept command acknowledgement as completion without external effect proof."},"id":"LibTmux::Batch::Operation.acknowledgement-only","kind":"property","modifiers":[],"name":"acknowledgement-only","package":"LibTmux","parent":"LibTmux::Batch::Operation","product":"core","publicId":"LibTmux::Batch::Operation.acknowledgement-only","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-batch-operation-acknowledgement-only"},{"apiScope":"exported","doc":{"body":"Revalidate replacements; unchanged evidence retains its one-shot Promise.","summary":"Revalidate replacements; unchanged evidence retains its one-shot Promise."},"id":"LibTmux::Batch::Operation.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Batch::Operation","product":"core","publicId":"LibTmux::Batch::Operation.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Operation:D)","references":[{"end":38,"start":27,"target":"LibTmux::Batch::Operation"}],"returns":"Operation:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Operation:D","target":"LibTmux::Batch::Operation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":70,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operation-clone"},{"apiScope":"exported","doc":{"body":"Immutable command admitted before any batch entry is dispatched.","summary":"Immutable command admitted before any batch entry is dispatched."},"id":"LibTmux::Batch::Operation.command","kind":"property","modifiers":[],"name":"command","package":"LibTmux","parent":"LibTmux::Batch::Operation","product":"core","publicId":"LibTmux::Batch::Operation.command","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Invocation:D","slug":"libtmux-batch-operation-command"},{"apiScope":"exported","doc":{"body":"Caller-owned Promise of Evidence; undefined in acknowledgement-only mode.","summary":"Caller-owned Promise of Evidence; undefined in acknowledgement-only mode."},"id":"LibTmux::Batch::Operation.evidence","kind":"property","modifiers":[],"name":"evidence","package":"LibTmux","parent":"LibTmux::Batch::Operation","product":"core","publicId":"LibTmux::Batch::Operation.evidence","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Promise","slug":"libtmux-batch-operation-evidence"},{"apiScope":"exported","doc":{"body":"Batch-unique correlation name, limited to 256 characters without NUL.","summary":"Batch-unique correlation name, limited to 256 characters without NUL."},"id":"LibTmux::Batch::Operation.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Batch::Operation","product":"core","publicId":"LibTmux::Batch::Operation.name","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-operation-name"},{"apiScope":"exported","doc":{"body":"One position's outcome, preserving its acknowledgement and original exception.","summary":"One position's outcome, preserving its acknowledgement and original exception."},"id":"LibTmux::Batch::OperationResult","kind":"class","modifiers":[],"name":"OperationResult","package":"LibTmux","parent":"LibTmux::Batch","product":"core","publicId":"LibTmux::Batch::OperationResult","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":82,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult"},{"apiScope":"exported","doc":{"body":"Whether a successful command acknowledgement was received before any later failure.","summary":"Whether a successful command acknowledgement was received before any later failure."},"id":"LibTmux::Batch::OperationResult.acknowledged","kind":"method","modifiers":[],"name":"acknowledged","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.acknowledged","signatures":[{"params":[],"raw":"method acknowledged(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"acknowledged","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":109,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult-acknowledged"},{"apiScope":"exported","doc":{"body":"Successful executor Receipt, or an undefined value when none was received.","summary":"Successful executor Receipt, or an undefined value when none was received."},"id":"LibTmux::Batch::OperationResult.acknowledgement","kind":"property","modifiers":[],"name":"acknowledgement","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.acknowledgement","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":92,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult-acknowledgement"},{"apiScope":"exported","doc":{"body":"Refuse altered copies of recorded execution outcomes.","summary":"Refuse altered copies of recorded execution outcomes."},"id":"LibTmux::Batch::OperationResult.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":107,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult-clone"},{"apiScope":"exported","doc":{"body":"command means acknowledgement; effect additionally requires satisfied Evidence.","summary":"command means acknowledgement; effect additionally requires satisfied Evidence."},"id":"LibTmux::Batch::OperationResult.completion-scope","kind":"property","modifiers":[],"name":"completion-scope","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.completion-scope","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-operationresult-completion-scope"},{"apiScope":"exported","doc":{"body":"Original execution/evidence exception; undefined for complete or skipped work.","summary":"Original execution/evidence exception; undefined for complete or skipped work."},"id":"LibTmux::Batch::OperationResult.error","kind":"property","modifiers":[],"name":"error","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.error","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":96,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Exception","slug":"libtmux-batch-operationresult-error"},{"apiScope":"exported","doc":{"body":"Preserve backend effect certainty even when batch classification differs.","summary":"Preserve backend effect certainty even when batch classification differs."},"id":"LibTmux::Batch::OperationResult.error-outcome","kind":"method","modifiers":[],"name":"error-outcome","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.error-outcome","signatures":[{"params":[],"raw":"method error-outcome(--> Outcome)","references":[{"end":32,"start":25,"target":"LibTmux::Types::Outcome"}],"returns":"Outcome","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"error-outcome","declaration":true},{"text":"(--> "},{"text":"Outcome","target":"LibTmux::Types::Outcome"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":111,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult-error-outcome"},{"apiScope":"exported","doc":{"body":"Observed caller Evidence when received, including an unsatisfied observation.","summary":"Observed caller Evidence when received, including an unsatisfied observation."},"id":"LibTmux::Batch::OperationResult.evidence","kind":"property","modifiers":[],"name":"evidence","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.evidence","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Evidence","slug":"libtmux-batch-operationresult-evidence"},{"apiScope":"exported","doc":{"body":"Time its outcome was recorded, not proof that an uncertain effect stopped.","summary":"Time its outcome was recorded, not proof that an uncertain effect stopped."},"id":"LibTmux::Batch::OperationResult.finished","kind":"property","modifiers":[],"name":"finished","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.finished","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":102,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-batch-operationresult-finished"},{"apiScope":"exported","doc":{"body":"Zero-based position in the admitted batch, including skipped entries.","summary":"Zero-based position in the admitted batch, including skipped entries."},"id":"LibTmux::Batch::OperationResult.index","kind":"property","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.index","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":84,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-batch-operationresult-index"},{"apiScope":"exported","doc":{"body":"Correlation name copied from the admitted operation.","summary":"Correlation name copied from the admitted operation."},"id":"LibTmux::Batch::OperationResult.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.name","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":86,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-operationresult-name"},{"apiScope":"exported","doc":{"body":"Refuse fabricated results; only Batch.run constructs execution observations.","summary":"Refuse fabricated results; only Batch.run constructs execution observations."},"id":"LibTmux::Batch::OperationResult.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":105,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-operationresult-new"},{"apiScope":"exported","doc":{"body":"Complete, Failed, Skipped or Indeterminate under this entry's completion scope.","summary":"Complete, Failed, Skipped or Indeterminate under this entry's completion scope."},"id":"LibTmux::Batch::OperationResult.outcome","kind":"property","modifiers":[],"name":"outcome","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.outcome","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Outcome:D","slug":"libtmux-batch-operationresult-outcome"},{"apiScope":"exported","doc":{"body":"Why dispatch was omitted; empty for an operation that was attempted.","summary":"Why dispatch was omitted; empty for an operation that was attempted."},"id":"LibTmux::Batch::OperationResult.skip-reason","kind":"property","modifiers":[],"name":"skip-reason","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.skip-reason","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":98,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-batch-operationresult-skip-reason"},{"apiScope":"exported","doc":{"body":"Admission time for this position, even when dispatch was skipped.","summary":"Admission time for this position, even when dispatch was skipped."},"id":"LibTmux::Batch::OperationResult.started","kind":"property","modifiers":[],"name":"started","package":"LibTmux","parent":"LibTmux::Batch::OperationResult","product":"core","publicId":"LibTmux::Batch::OperationResult.started","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":100,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-batch-operationresult-started"},{"apiScope":"exported","doc":{"body":"Captured per-operation results. No runtime, control owner or caller task is retained.","summary":"Captured per-operation results. No runtime, control owner or caller task is retained."},"id":"LibTmux::Batch::Report","kind":"class","modifiers":[],"name":"Report","package":"LibTmux","parent":"LibTmux::Batch","product":"core","publicId":"LibTmux::Batch::Report","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":117,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-report"},{"apiScope":"exported","doc":{"body":"Refuse altered copies of recorded batch outcomes.","summary":"Refuse altered copies of recorded batch outcomes."},"id":"LibTmux::Batch::Report.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":136,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-report-clone"},{"apiScope":"exported","doc":{"body":"One absolute deadline shared by execution and caller-evidence waiting.","summary":"One absolute deadline shared by execution and caller-evidence waiting."},"id":"LibTmux::Batch::Report.deadline","kind":"property","modifiers":[],"name":"deadline","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.deadline","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":125,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-batch-report-deadline"},{"apiScope":"exported","doc":{"body":"Time all positions were classified, including the undispatched suffix.","summary":"Time all positions were classified, including the undispatched suffix."},"id":"LibTmux::Batch::Report.finished","kind":"property","modifiers":[],"name":"finished","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.finished","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":123,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-batch-report-finished"},{"apiScope":"exported","doc":{"body":"Refuse fabricated reports; only Batch.run records a complete batch attempt.","summary":"Refuse fabricated reports; only Batch.run records a complete batch attempt."},"id":"LibTmux::Batch::Report.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":134,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-report-new"},{"apiScope":"exported","doc":{"body":"Eager immutable membership containing one OperationResult per admitted entry.","summary":"Eager immutable membership containing one OperationResult per admitted entry."},"id":"LibTmux::Batch::Report.operations","kind":"property","modifiers":[],"name":"operations","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.operations","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":119,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-batch-report-operations"},{"apiScope":"exported","doc":{"body":"Aggregate uncertainty first, then failure, skipped work, and complete work.","summary":"Aggregate uncertainty first, then failure, skipped work, and complete work."},"id":"LibTmux::Batch::Report.outcome","kind":"method","modifiers":[],"name":"outcome","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.outcome","signatures":[{"params":[],"raw":"method outcome(--> Outcome:D)","references":[{"end":28,"start":19,"target":"LibTmux::Types::Outcome"}],"returns":"Outcome:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"outcome","declaration":true},{"text":"(--> "},{"text":"Outcome:D","target":"LibTmux::Types::Outcome"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Batch.rakumod","line":138,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-batch-report-outcome"},{"apiScope":"exported","doc":{"body":"Admission threshold in bytes; the final retained response may exceed it.","summary":"Admission threshold in bytes; the final retained response may exceed it."},"id":"LibTmux::Batch::Report.output-budget-bytes","kind":"property","modifiers":[],"name":"output-budget-bytes","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.output-budget-bytes","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":131,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-batch-report-output-budget-bytes"},{"apiScope":"exported","doc":{"body":"Counted receipt and Command-error bytes, with shared causes counted once.","summary":"Counted receipt and Command-error bytes, with shared causes counted once."},"id":"LibTmux::Batch::Report.output-bytes","kind":"property","modifiers":[],"name":"output-bytes","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.output-bytes","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":129,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-batch-report-output-bytes"},{"apiScope":"exported","doc":{"body":"Time before command preflight began; the overall deadline starts here.","summary":"Time before command preflight began; the overall deadline starts here."},"id":"LibTmux::Batch::Report.started","kind":"property","modifiers":[],"name":"started","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.started","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":121,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-batch-report-started"},{"apiScope":"exported","doc":{"body":"Cause that requested a stop; undefined when no stopping condition occurred.","summary":"Cause that requested a stop; undefined when no stopping condition occurred."},"id":"LibTmux::Batch::Report.stop-error","kind":"property","modifiers":[],"name":"stop-error","package":"LibTmux","parent":"LibTmux::Batch::Report","product":"core","publicId":"LibTmux::Batch::Report.stop-error","signatures":[],"source":{"file":"lib/LibTmux/Batch.rakumod","line":127,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Exception","slug":"libtmux-batch-report-stop-error"},{"apiScope":"exported","doc":{"body":"# Capability observations\nConstruction consumes explicit observations and packaged catalogue data. It\nnever launches tmux. Replacing a daemon or negotiating connection flags needs\na new capability object. The engine binds these observations to actual\ndaemon identity; this class does not establish that identity by itself.\n\n` supports ` and ` require ` describe native features. A fallback identifies an\nalternative which the caller must choose explicitly. ` workaround ` describes\nrequired handling; it never claims the repair was performed. Field support\ndoes not mean the field was acquired or is available in every context.","summary":""},"id":"LibTmux::Capabilities","kind":"class","modifiers":[],"name":"Capabilities","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Capabilities","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities"},{"apiScope":"exported","doc":{"body":"Independently observed executable version, retained for diagnostics.","summary":"Independently observed executable version, retained for diagnostics."},"id":"LibTmux::Capabilities.client-version","kind":"property","modifiers":[],"name":"client-version","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.client-version","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":38,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-client-version"},{"apiScope":"exported","doc":{"body":"Reconstruct copies so changed observations cannot retain stale parsed evidence.","summary":"Reconstruct copies so changed observations cannot retain stale parsed evidence."},"id":"LibTmux::Capabilities.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> LibTmux::Capabilities:D)","references":[{"end":50,"start":27,"target":"LibTmux::Capabilities"}],"returns":"LibTmux::Capabilities:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"LibTmux::Capabilities:D","target":"LibTmux::Capabilities"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":60,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-clone"},{"apiScope":"exported","doc":{"body":"Codec identifier selected through catalogue policy: qa or t6.","summary":"Codec identifier selected through catalogue policy: qa or t6."},"id":"LibTmux::Capabilities.codec-profile","kind":"method","modifiers":[],"name":"codec-profile","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.codec-profile","signatures":[{"params":[],"raw":"method codec-profile(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"codec-profile","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":160,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-codec-profile"},{"apiScope":"exported","doc":{"body":"Version observed from the daemon; client version does not establish support.","summary":"Version observed from the daemon; client version does not establish support."},"id":"LibTmux::Capabilities.daemon-version","kind":"property","modifiers":[],"name":"daemon-version","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.daemon-version","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-daemon-version"},{"apiScope":"exported","doc":{"body":"All discoverable feature decisions for this immutable observation.","summary":"All discoverable feature decisions for this immutable observation."},"id":"LibTmux::Capabilities.features","kind":"method","modifiers":[],"name":"features","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.features","signatures":[{"params":[],"raw":"method features(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"features","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":150,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-features"},{"apiScope":"exported","doc":{"body":"Availability of a registered field, independent of acquisition completeness.","summary":"Availability of a registered field, independent of acquisition completeness."},"id":"LibTmux::Capabilities.field-status","kind":"method","modifiers":[],"name":"field-status","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.field-status","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method field-status(Str:D $entity, Str:D $name --> Decision:D)","references":[{"end":61,"start":51,"target":"LibTmux::Capabilities::Decision"}],"returns":"Decision:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"field-status","declaration":true},{"text":"(Str:D $entity, Str:D $name --> "},{"text":"Decision:D","target":"LibTmux::Capabilities::Decision"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":183,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-field-status"},{"apiScope":"exported","doc":{"body":"Opaque immutable identity supplied by the engine's explicit identity probe.","summary":"Opaque immutable identity supplied by the engine's explicit identity probe."},"id":"LibTmux::Capabilities.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":40,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-incarnation"},{"apiScope":"exported","doc":{"body":"Default captured-layout dialect. Control negotiation remains explicit.","summary":"Default captured-layout dialect. Control negotiation remains explicit."},"id":"LibTmux::Capabilities.layout-profile","kind":"method","modifiers":[],"name":"layout-profile","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.layout-profile","signatures":[{"params":[],"raw":"method layout-profile(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"layout-profile","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":175,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-layout-profile"},{"apiScope":"exported","doc":{"body":"Flags already negotiated by an explicitly owned connection.","summary":"Flags already negotiated by an explicitly owned connection."},"id":"LibTmux::Capabilities.negotiated-features","kind":"property","modifiers":[],"name":"negotiated-features","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.negotiated-features","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":44,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-capabilities-negotiated-features"},{"apiScope":"exported","doc":{"body":"Required legacy decoding stage: vis or none. No repair has run here.","summary":"Required legacy decoding stage: vis or none. No repair has run here."},"id":"LibTmux::Capabilities.output-repair","kind":"method","modifiers":[],"name":"output-repair","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.output-repair","signatures":[{"params":[],"raw":"method output-repair(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"output-repair","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":169,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-output-repair"},{"apiScope":"exported","doc":{"body":"Parsed executable release retained for diagnostics, not daemon feature decisions.","summary":"Parsed executable release retained for diagnostics, not daemon feature decisions."},"id":"LibTmux::Capabilities.parsed-client-version","kind":"method","modifiers":[],"name":"parsed-client-version","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.parsed-client-version","signatures":[{"params":[],"raw":"method parsed-client-version(--> TmuxVersion:D)","references":[{"end":46,"start":33,"target":"LibTmux::Catalogue::TmuxVersion"}],"returns":"TmuxVersion:D","nativeSyntax":[{"start":7,"end":28,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"parsed-client-version","declaration":true},{"text":"(--> "},{"text":"TmuxVersion:D","target":"LibTmux::Catalogue::TmuxVersion"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":76,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-parsed-client-version"},{"apiScope":"exported","doc":{"body":"Parsed daemon release; syntactic stability does not establish a support profile.","summary":"Parsed daemon release; syntactic stability does not establish a support profile."},"id":"LibTmux::Capabilities.parsed-daemon-version","kind":"method","modifiers":[],"name":"parsed-daemon-version","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.parsed-daemon-version","signatures":[{"params":[],"raw":"method parsed-daemon-version(--> TmuxVersion:D)","references":[{"end":46,"start":33,"target":"LibTmux::Catalogue::TmuxVersion"}],"returns":"TmuxVersion:D","nativeSyntax":[{"start":7,"end":28,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"parsed-daemon-version","declaration":true},{"text":"(--> "},{"text":"TmuxVersion:D","target":"LibTmux::Catalogue::TmuxVersion"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-parsed-daemon-version"},{"apiScope":"exported","doc":{"body":"Require native support or throw a typed, reason-bearing refusal.","summary":"Require native support or throw a typed, reason-bearing refusal."},"id":"LibTmux::Capabilities.require","kind":"method","modifiers":[],"name":"require","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.require","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method require(Str:D $id --> Decision:D)","references":[{"end":39,"start":29,"target":"LibTmux::Capabilities::Decision"}],"returns":"Decision:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"require","declaration":true},{"text":"(Str:D $id --> "},{"text":"Decision:D","target":"LibTmux::Capabilities::Decision"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":129,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-require"},{"apiScope":"exported","doc":{"body":"Return the supported field specification or throw Unsupported with its reason.","summary":"Return the supported field specification or throw Unsupported with its reason."},"id":"LibTmux::Capabilities.require-field","kind":"method","modifiers":[],"name":"require-field","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.require-field","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method require-field(Str:D $entity, Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"require-field","declaration":true},{"text":"(Str:D $entity, Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":205,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-require-field"},{"apiScope":"exported","doc":{"body":"How the caller acquired the daemon observation.","summary":"How the caller acquired the daemon observation."},"id":"LibTmux::Capabilities.source","kind":"property","modifiers":[],"name":"source","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.source","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":42,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-source"},{"apiScope":"exported","doc":{"body":"Inspect one feature without I/O. Unknown names remain explicitly unknown.","summary":"Inspect one feature without I/O. Unknown names remain explicitly unknown."},"id":"LibTmux::Capabilities.status","kind":"method","modifiers":[],"name":"status","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.status","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method status(Str:D $id --> Decision:D)","references":[{"end":38,"start":28,"target":"LibTmux::Capabilities::Decision"}],"returns":"Decision:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"status","declaration":true},{"text":"(Str:D $id --> "},{"text":"Decision:D","target":"LibTmux::Capabilities::Decision"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":118,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-status"},{"apiScope":"exported","doc":{"body":"Native support only; an available fallback does not make the feature native.","summary":"Native support only; an available fallback does not make the feature native."},"id":"LibTmux::Capabilities.supports","kind":"method","modifiers":[],"name":"supports","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.supports","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method supports(Str:D $id --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"supports","declaration":true},{"text":"(Str:D $id --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":126,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-supports"},{"apiScope":"exported","doc":{"body":"Whether the observed daemon supports the registered field; unknown means False.","summary":"Whether the observed daemon supports the registered field; unknown means False."},"id":"LibTmux::Capabilities.supports-field","kind":"method","modifiers":[],"name":"supports-field","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.supports-field","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method supports-field(Str:D $entity, Str:D $name --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"supports-field","declaration":true},{"text":"(Str:D $entity, Str:D $name --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":200,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-supports-field"},{"apiScope":"exported","doc":{"body":"Inspect an upstream defect. applies means handling is needed, not completed.","summary":"Inspect an upstream defect. applies means handling is needed, not completed."},"id":"LibTmux::Capabilities.workaround","kind":"method","modifiers":[],"name":"workaround","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.workaround","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method workaround(Str:D $id --> Decision:D)","references":[{"end":42,"start":32,"target":"LibTmux::Capabilities::Decision"}],"returns":"Decision:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"workaround","declaration":true},{"text":"(Str:D $id --> "},{"text":"Decision:D","target":"LibTmux::Capabilities::Decision"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":142,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-workaround"},{"apiScope":"exported","doc":{"body":"All declared defects, including those which do not apply to this release.","summary":"All declared defects, including those which do not apply to this release."},"id":"LibTmux::Capabilities.workarounds","kind":"method","modifiers":[],"name":"workarounds","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities.workarounds","signatures":[{"params":[],"raw":"method workarounds(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"workarounds","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-workarounds"},{"apiScope":"exported","doc":{"body":"Evidence and required handling; a repair policy never means repair ran.","summary":"Evidence and required handling; a repair policy never means repair ran."},"id":"LibTmux::Capabilities::Decision","kind":"class","modifiers":[],"name":"Decision","package":"LibTmux","parent":"LibTmux::Capabilities","product":"core","publicId":"LibTmux::Capabilities::Decision","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":11,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-decision"},{"apiScope":"exported","doc":{"body":"Whether this defect needs handling; True does not mean a repair has run.","summary":"Whether this defect needs handling; True does not mean a repair has run."},"id":"LibTmux::Capabilities::Decision.applies","kind":"method","modifiers":[],"name":"applies","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.applies","signatures":[{"params":[],"raw":"method applies(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"applies","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-decision-applies"},{"apiScope":"exported","doc":{"body":"Provenance label from the immutable daemon capability observation.","summary":"Provenance label from the immutable daemon capability observation."},"id":"LibTmux::Capabilities::Decision.evidence","kind":"property","modifiers":[],"name":"evidence","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.evidence","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-evidence"},{"apiScope":"exported","doc":{"body":"Explicit alternative capability identifier; empty when no fallback is declared.","summary":"Explicit alternative capability identifier; empty when no fallback is declared."},"id":"LibTmux::Capabilities::Decision.fallback","kind":"property","modifiers":[],"name":"fallback","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.fallback","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-fallback"},{"apiScope":"exported","doc":{"body":"Refusal, fallback or repair policy; it does not record an executed action.","summary":"Refusal, fallback or repair policy; it does not record an executed action."},"id":"LibTmux::Capabilities::Decision.handling","kind":"property","modifiers":[],"name":"handling","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.handling","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-handling"},{"apiScope":"exported","doc":{"body":"Catalogue feature, field or defect identifier used by this decision.","summary":"Catalogue feature, field or defect identifier used by this decision."},"id":"LibTmux::Capabilities::Decision.id","kind":"property","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.id","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":13,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-id"},{"apiScope":"exported","doc":{"body":"Whether the decision concerns a feature, field or known upstream defect.","summary":"Whether the decision concerns a feature, field or known upstream defect."},"id":"LibTmux::Capabilities::Decision.kind","kind":"property","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.kind","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":15,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-kind"},{"apiScope":"exported","doc":{"body":"Explanation of availability, missing evidence or a blocking defect.","summary":"Explanation of availability, missing evidence or a blocking defect."},"id":"LibTmux::Capabilities::Decision.reason","kind":"property","modifiers":[],"name":"reason","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.reason","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-reason"},{"apiScope":"exported","doc":{"body":"Pinned upstream source supporting the policy, or empty when no rule exists.","summary":"Pinned upstream source supporting the policy, or empty when no rule exists."},"id":"LibTmux::Capabilities::Decision.source","kind":"property","modifiers":[],"name":"source","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.source","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":23,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-capabilities-decision-source"},{"apiScope":"exported","doc":{"body":"Qualified support state; Unknown is distinct from an unsupported release.","summary":"Qualified support state; Unknown is distinct from an unsupported release."},"id":"LibTmux::Capabilities::Decision.state","kind":"property","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.state","signatures":[],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SupportState:D","slug":"libtmux-capabilities-decision-state"},{"apiScope":"exported","doc":{"body":"True only for a supported feature or field, never for a known defect.","summary":"True only for a supported feature or field, never for a known defect."},"id":"LibTmux::Capabilities::Decision.supported","kind":"method","modifiers":[],"name":"supported","package":"LibTmux","parent":"LibTmux::Capabilities::Decision","product":"core","publicId":"LibTmux::Capabilities::Decision.supported","signatures":[{"params":[],"raw":"method supported(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"supported","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Capabilities.rakumod","line":30,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-capabilities-decision-supported"},{"apiScope":"exported","doc":{"body":"Packaged, source-qualified fields, relationships, options and release profiles.\n\n# LibTmux field and capability catalogue\n\nGenerated from the packaged resources. Edit the resources and regenerate this file.\n\nAvailability identifies source support; it does not establish acquisition completeness.\n\n\n\n## session\n\n\n\n- ` id ` / ` id `\n\nFORMAT ` session_id `; session-id; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` name ` / ` name `\n\nFORMAT ` session_name `; text; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` windows-count ` / ` windowsCount `\n\nFORMAT ` session_windows `; uint; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` attached-count ` / ` attachedCount `\n\nFORMAT ` session_attached `; uint; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` created ` / ` created `\n\nFORMAT ` session_created `; uint; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` activity ` / ` activity `\n\nFORMAT ` session_activity `; uint; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` path ` / ` path `\n\nFORMAT ` session_path `; text; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` grouped ` / ` grouped `\n\nFORMAT ` session_grouped `; bool; context session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` group-name ` / ` groupName `\n\nFORMAT ` session_group `; text; context session; nullable True; since 3.3a.\n\nNull policy: not-grouped; dependency: grouped.\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` window-links ` relation\n\nmany window-link; nullable False.\n\n\n\n- ` current-link ` relation\n\none window-link; nullable False.\n\n\n\n- ` group ` relation\n\none session-group; nullable True.\n\n\n\n## window-link\n\n\n\n- ` session-id ` / ` sessionId `\n\nFORMAT ` session_id `; session-id; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` window-id ` / ` windowId `\n\nFORMAT ` window_id `; window-id; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` index ` / ` index `\n\nFORMAT ` window_index `; uint; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nExact source operators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nSource numeric domain: 0 through 2147483647.\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` active ` / ` active `\n\nFORMAT ` window_active `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` last ` / ` last `\n\nFORMAT ` window_last_flag `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` activity ` / ` activity `\n\nFORMAT ` window_activity_flag `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` bell ` / ` bell `\n\nFORMAT ` window_bell_flag `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` silence ` / ` silence `\n\nFORMAT ` window_silence_flag `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` session ` relation\n\none session; nullable False.\n\n\n\n- ` window ` relation\n\none window; nullable False.\n\n\n\n## window\n\n\n\n- ` id ` / ` id `\n\nFORMAT ` window_id `; window-id; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` name ` / ` name `\n\nFORMAT ` window_name `; text; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` width ` / ` width `\n\nFORMAT ` window_width `; uint; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nExact source operators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nSource numeric domain: 0 through 4294967295.\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` height ` / ` height `\n\nFORMAT ` window_height `; uint; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nExact source operators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nSource numeric domain: 0 through 4294967295.\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` panes-count ` / ` panesCount `\n\nFORMAT ` window_panes `; uint; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` layout ` / ` layout `\n\nFORMAT ` window_layout `; text; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` visible-layout ` / ` visibleLayout `\n\nFORMAT ` window_visible_layout `; text; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` zoomed ` / ` zoomed `\n\nFORMAT ` window_zoomed_flag `; bool; context window; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` linked ` / ` linked `\n\nFORMAT ` window_linked `; bool; context window-link; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` modal-pane-id ` / ` modalPaneId `\n\nFORMAT ` window_modal_pane `; pane-id; context window; nullable True; since 3.8.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` panes ` relation\n\nmany pane; nullable False.\n\n\n\n- ` links ` relation\n\nmany window-link; nullable False.\n\n\n\n- ` active-pane ` relation\n\none pane; nullable False.\n\n\n\n## pane\n\n\n\n- ` id ` / ` id `\n\nFORMAT ` pane_id `; pane-id; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` window-id ` / ` windowId `\n\nFORMAT ` window_id `; window-id; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` index ` / ` index `\n\nFORMAT ` pane_index `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` active ` / ` active `\n\nFORMAT ` pane_active `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` width ` / ` width `\n\nFORMAT ` pane_width `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nExact source operators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nSource numeric domain: 0 through 4294967295.\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` height ` / ` height `\n\nFORMAT ` pane_height `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nExact source operators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\nSource numeric domain: 0 through 4294967295.\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/tmux.h)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` left ` / ` left `\n\nFORMAT ` pane_left `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` top ` / ` top `\n\nFORMAT ` pane_top `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` pid ` / ` pid `\n\nFORMAT ` pane_pid `; uint; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` tty ` / ` tty `\n\nFORMAT ` pane_tty `; text; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` title ` / ` title `\n\nFORMAT ` pane_title `; text; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` current-command ` / ` currentCommand `\n\nFORMAT ` pane_current_command `; text; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` current-path ` / ` currentPath `\n\nFORMAT ` pane_current_path `; text; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` start-command ` / ` startCommand `\n\nFORMAT ` pane_start_command `; text; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` start-path ` / ` startPath `\n\nFORMAT ` pane_start_path `; text; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` dead ` / ` dead `\n\nFORMAT ` pane_dead `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\nExact source operators: equals, not-equals, in, not-in.\n\n\n\nPushdown evidence: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` dead-status ` / ` deadStatus `\n\nFORMAT ` pane_dead_status `; uint; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` dead-signal ` / ` deadSignal `\n\nFORMAT ` pane_dead_signal `; text; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` dead-time ` / ` deadTime `\n\nFORMAT ` pane_dead_time `; uint; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` in-mode ` / ` inMode `\n\nFORMAT ` pane_in_mode `; uint; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` mode ` / ` mode `\n\nFORMAT ` pane_mode `; text; context pane; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` pipe ` / ` pipe `\n\nFORMAT ` pane_pipe `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` synchronized ` / ` synchronized `\n\nFORMAT ` pane_synchronized `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` floating ` / ` floating `\n\nFORMAT ` pane_floating_flag `; bool; context pane; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c)\n\n\n\n- ` modal ` / ` modal `\n\nFORMAT ` pane_modal_flag `; bool; context pane; nullable False; since 3.8.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` x ` / ` x `\n\nFORMAT ` pane_x `; int; context pane; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c)\n\n\n\n- ` y ` / ` y `\n\nFORMAT ` pane_y `; int; context pane; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c)\n\n\n\n- ` z ` / ` z `\n\nFORMAT ` pane_z `; uint; context pane; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c)\n\n\n\n- ` command-running ` / ` commandRunning `\n\nFORMAT ` pane_command_running `; bool; context pane; nullable False; since 3.8.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` command-status ` / ` commandStatus `\n\nFORMAT ` pane_command_status `; int; context pane; nullable True; since 3.8.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/format.c)\n\n\n\n- ` at-top ` / ` atTop `\n\nFORMAT ` pane_at_top `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` at-bottom ` / ` atBottom `\n\nFORMAT ` pane_at_bottom `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` at-left ` / ` atLeft `\n\nFORMAT ` pane_at_left `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` at-right ` / ` atRight `\n\nFORMAT ` pane_at_right `; bool; context pane; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` window ` relation\n\none window; nullable False.\n\n\n\n## client\n\n\n\n- ` name ` / ` name `\n\nFORMAT ` client_name `; text; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` session-id ` / ` sessionId `\n\nFORMAT ` session_id `; session-id; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` session-name ` / ` sessionName `\n\nFORMAT ` client_session `; text; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` tty ` / ` tty `\n\nFORMAT ` client_tty `; text; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` pid ` / ` pid `\n\nFORMAT ` client_pid `; uint; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` width ` / ` width `\n\nFORMAT ` client_width `; uint; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` height ` / ` height `\n\nFORMAT ` client_height `; uint; context client; nullable True; since 3.3a.\n\nNull policy: empty; dependency: none.\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte, is-null.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c#L1283](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c#L1283)\n\n\n\n- ` created ` / ` created `\n\nFORMAT ` client_created `; uint; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` activity ` / ` activity `\n\nFORMAT ` client_activity `; uint; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` control-mode ` / ` controlMode `\n\nFORMAT ` client_control_mode `; bool; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` read-only ` / ` readOnly `\n\nFORMAT ` client_readonly `; bool; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` terminal-name ` / ` terminalName `\n\nFORMAT ` client_termname `; text; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` key-table ` / ` keyTable `\n\nFORMAT ` client_key_table `; text; context client; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` session ` relation\n\none session; nullable False.\n\n\n\n## session-group\n\n\n\n- ` name ` / ` name `\n\nFORMAT ` session_group `; text; context grouped-session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` size ` / ` size `\n\nFORMAT ` session_group_size `; uint; context grouped-session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` attached-count ` / ` attachedCount `\n\nFORMAT ` session_group_attached `; uint; context grouped-session; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` sessions ` relation\n\nmany session; nullable False.\n\n\n\n## buffer\n\n\n\n- ` name ` / ` name `\n\nFORMAT ` buffer_name `; text; context buffer; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` size ` / ` size `\n\nFORMAT ` buffer_size `; uint; context buffer; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` created ` / ` created `\n\nFORMAT ` buffer_created `; uint; context buffer; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, lt, lte, gt, gte.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` sample ` / ` sample `\n\nFORMAT ` buffer_sample `; text; context buffer; nullable False; since 3.3a.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n## key-binding\n\n\n\n- ` table ` / ` table `\n\nFORMAT ` key_table `; text; context key-binding; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n- ` key ` / ` key `\n\nFORMAT ` key_string `; text; context key-binding; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n- ` repeat ` / ` repeat `\n\nFORMAT ` key_repeat `; bool; context key-binding; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n- ` command-source ` / ` commandSource `\n\nFORMAT ` key_command `; text; context key-binding; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n- ` note ` / ` note `\n\nFORMAT ` key_note `; text; context key-binding; nullable False; since 3.7.\n\n\n\nOperators: equals, not-equals, in, not-in, contains, starts-with, ends-with.\n\n\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n## Features and required handling\n\n\n\n- ` managed-commands `\n\nfeature; refuse; since 3.3a. Managed commands require an exact declared daemon release profile.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/cmd.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/cmd.c)\n\n\n\n- ` format-tilde `\n\nfeature; refuse; since 3.3a. Six ordered substitutions encode delimiters, backslashes and dollar signs.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/format.c)\n\n\n\n- ` format-argument-quote `\n\nfeature; fallback; since 3.7. q/a is introduced in 3.7; older profiles use the tested tilde codec.\n\nFallback: ` format-tilde `.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/format.c)\n\n\n\n- ` format-output-vis `\n\ndefect; repair; exact releases 3.4, 3.5, 3.5a. Reverse one VIS output layer before decoding the tilde field.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/server-client.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/server-client.c)\n\n\n\n- ` layout-classic `\n\nfeature; refuse; since 3.3a. Classic layouts remain available for old layouts and unnegotiated control clients.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/layout-custom.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/layout-custom.c)\n\n\n\n- ` layout-json `\n\nfeature; refuse; since 3.8. JSON layouts include floating placements in the current profile.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/layout-custom.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/layout-custom.c)\n\n\n\n- ` control-mode `\n\nfeature; refuse; since 3.3a. Control framing is available at the support floor.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/control.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/control.c)\n\n\n\n- ` control-new-layouts `\n\nfeature; refuse; since 3.8. Enable new-layouts explicitly before interpreting new control layouts.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/server-client.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/server-client.c)\n\n\n\n- ` pane-floating `\n\nfeature; refuse; since 3.7. Floating panes and their coordinates are available starting in 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-split-window.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-split-window.c)\n\n\n\n- ` pane-modal `\n\nfeature; refuse; since 3.8. Modal panes and modal-window fields require 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-split-window.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-split-window.c)\n\n\n\n- ` buffer-full `\n\nfeature; fallback; since 3.6. Use save-buffer when buffer_full is unavailable.\n\nFallback: ` buffer-save `.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/format.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/format.c)\n\n\n\n- ` buffer-save `\n\nfeature; refuse; since 3.3a. Binary save-buffer capture is separate from FORMAT framing.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/cmd-save-buffer.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/cmd-save-buffer.c)\n\n\n\n- ` layout-mirrored-main `\n\nfeature; refuse; since 3.5. Mirrored main-horizontal and main-vertical layouts require 3.5.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/layout-set.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/layout-set.c)\n\n\n\n- ` split-percent-defect `\n\ndefect; refuse; exact releases 3.4. split-window -p is broken in 3.4; use the explicit -l percentage form.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/cmd-split-window.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/cmd-split-window.c)\n\n\n\n- ` break-pane-name-defect `\n\ndefect; refuse; exact releases 3.7. tmux 3.7 ignores explicit break-pane names and dereferences a null name in the unnamed multi-pane path; refuse break-pane before dispatch.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-break-pane.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-break-pane.c)\n\n\n\n- ` name-separator-defect `\n\ndefect; refuse; exact releases 3.7. tmux 3.7 rejects colon and dot names; validate their capability before dispatch.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/tmux.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/tmux.c)\n\n\n\n- ` session-name-separators `\n\nfeature; refuse; since 3.7a. Literal dot and colon in session names require 3.7a; earlier releases replace or reject them.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0e418b62d259ce8da8970f75732cc6632ee4c3a0/tmux.c#L285](https://github.com/tmux/tmux/blob/0e418b62d259ce8da8970f75732cc6632ee4c3a0/tmux.c#L285)\n\n\n\n- ` window-name-separators `\n\nfeature; refuse; since 3.3a. Literal dot and colon in window names are supported unless the declared separator defect applies.\n\n\n\nBlocked by: name-separator-defect.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/window.c#L405](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/window.c#L405)\n\n\n\n- ` pane-empty-flag `\n\nfeature; refuse; since 3.7. Explicit empty split panes use -E from 3.7; older releases require the declared empty-argument adapter.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-split-window.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-split-window.c)\n\n\n\n- ` window-empty `\n\nfeature; refuse; since 3.8. Empty window creation requires the new-window -E flag from 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-new-window.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-new-window.c)\n\n\n\n- ` break-pane-single-print `\n\nfeature; refuse; since 3.6. Breaking the only pane prints its returned identity from 3.6; older releases need an explicit scoped identity acquisition.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-break-pane.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-break-pane.c)\n\n\n\n- ` pane-floating-move `\n\nfeature; refuse; since 3.8. Floating pane position and stack changes require move-pane placement flags from 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-join-pane.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/cmd-join-pane.c)\n\n\n\n- ` control-job-output `\n\nfeature; refuse; since 3.5. Foreground run-shell job output is delivered to the command client from 3.5; earlier releases send it to pane view mode. This does not guarantee shell-output framing.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/cmd-run-shell.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/cmd-run-shell.c)\n\n\n\n- ` menu-appearance `\n\nfeature; refuse; since 3.4. Menu border, style, selected style and initial choice flags are available from 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/cmd-display-menu.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/cmd-display-menu.c)\n\n\n\n- ` menu-mouse `\n\nfeature; refuse; since 3.5. The display-menu -M flag enables mouse selection without a triggering mouse event from 3.5.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/cmd-display-menu.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/cmd-display-menu.c)\n\n\n\n- ` popup-close-on-key `\n\nfeature; refuse; since 3.6. The display-popup -k flag requests close on any key from 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-display-menu.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-display-menu.c)\n\n\n\n- ` popup-reset-flags `\n\nfeature; refuse; since 3.6. The display-popup -N flag resets existing popup flags from 3.6; omitted flags otherwise preserve the existing popup policy.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-display-menu.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-display-menu.c)\n\n\n\n- ` prompt-literal-commas `\n\nfeature; refuse; since 3.6. The command-prompt -l flag retains commas in one prompt and initial input from 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-command-prompt.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/cmd-command-prompt.c)\n\n\n\n- ` key-binding-format `\n\nfeature; refuse; since 3.7. Key table, key, repeat, note and native command source can be projected with list-keys -F from 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/cmd-list-keys.c)\n\n\n\n## Option types and scopes\n\n\n\n- ` activity-action `\n\nchoice; scope session; since 3.3a.\n\nChoices: none, any, current, other.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-bind-key `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-capture-pane `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-copy-mode `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-display-message `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-display-panes `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-kill-pane `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-buffers `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-clients `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-keys `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-panes `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-sessions `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-list-windows `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-load-buffer `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-lock-server `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-new-session `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-new-window `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-paste-buffer `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-pipe-pane `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-queue `\n\ncommand; scope session; since 3.3a, before 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-refresh-client `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-rename-session `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-rename-window `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-resize-pane `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-resize-window `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-save-buffer `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-select-layout `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-select-pane `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-select-window `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-send-keys `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-set-buffer `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-set-environment `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-set-hook `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-set-option `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-show-environment `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-show-messages `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-show-options `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-split-window `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` after-swap-window `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` after-unbind-key `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` aggressive-resize `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` alert-activity `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` alert-bell `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` alert-silence `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` allow-passthrough `\n\nflag; scope window, pane; since 3.3a, before 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` allow-passthrough `\n\nchoice; scope window, pane; since 3.4.\n\nChoices: off, on, all.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` allow-rename `\n\nflag; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` allow-set-title `\n\nflag; scope window, pane; since 3.5.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c)\n\n\n\n- ` alternate-screen `\n\nflag; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` assume-paste-time `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` automatic-rename `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` automatic-rename-format `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` backspace `\n\nkey; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` base-index `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` bell-action `\n\nchoice; scope session; since 3.3a.\n\nChoices: none, any, current, other.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` buffer-limit `\n\nnumber; scope server; since 3.3a.\n\n\n\nRange: 1 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` clear-on-attach `\n\nflag; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` client-active `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-attached `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-closed `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` client-created `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` client-dark-theme `\n\ncommand; scope session; since 3.6. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` client-detached `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-focus-in `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-focus-out `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-light-theme `\n\ncommand; scope session; since 3.6. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` client-resized `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` client-session-changed `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` clock-mode-colour `\n\ncolour; scope window; since 3.3a, before 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` clock-mode-colour `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` clock-mode-style `\n\nchoice; scope window; since 3.3a, before 3.6.\n\nChoices: 12, 24.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` clock-mode-style `\n\nchoice; scope window; since 3.6.\n\nChoices: 12, 24, 12-with-seconds, 24-with-seconds.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` codepoint-widths `\n\nstring; scope server; since 3.6. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` command-alias `\n\nstring; scope server; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` command-error `\n\ncommand; scope session; since 3.5. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c)\n\n\n\n- ` copy-command `\n\nstring; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` copy-mode-current-line-number-style `\n\nstring; scope window; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` copy-mode-current-line-style `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` copy-mode-current-match-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` copy-mode-line-number-style `\n\nstring; scope window; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` copy-mode-line-numbers `\n\nchoice; scope window; since 3.7.\n\nChoices: off, default, absolute, relative, hybrid.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` copy-mode-mark-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` copy-mode-match-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` copy-mode-position-format `\n\nstring; scope window, pane; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` copy-mode-position-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` copy-mode-selection-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` cursor-colour `\n\ncolour; scope window, pane; since 3.3a, before 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` cursor-colour `\n\nstring; scope window, pane; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` cursor-style `\n\nchoice; scope window, pane; since 3.3a.\n\nChoices: default, blinking-block, block, blinking-underline, underline, blinking-bar, bar.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` dark-theme-black `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-blue `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-cyan `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-dark-grey `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-green `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-light-grey `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-magenta `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-red `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-white `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` dark-theme-yellow `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` default-client-command `\n\ncommand; scope server; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` default-command `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` default-shell `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` default-size `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` default-terminal `\n\nstring; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` destroy-unattached `\n\nflag; scope session; since 3.3a, before 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` destroy-unattached `\n\nchoice; scope session; since 3.4.\n\nChoices: off, on, keep-last, keep-group.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` detach-on-destroy `\n\nchoice; scope session; since 3.3a, before 3.4.\n\nChoices: off, on, no-detached.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` detach-on-destroy `\n\nchoice; scope session; since 3.4.\n\nChoices: off, on, no-detached, previous, next.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` display-panes-active-colour `\n\ncolour; scope session; since 3.3a, before 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` display-panes-active-colour `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` display-panes-border-style `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` display-panes-colour `\n\ncolour; scope session; since 3.3a, before 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` display-panes-colour `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` display-panes-format `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` display-panes-time `\n\nnumber; scope session; since 3.3a, before 3.8.\n\n\n\nRange: 1 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` display-panes-time `\n\nnumber; scope window; since 3.8.\n\n\n\nRange: 1 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` display-time `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` editor `\n\nstring; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` escape-time `\n\nnumber; scope server; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` exit-empty `\n\nflag; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` exit-unattached `\n\nflag; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` extended-keys `\n\nchoice; scope server; since 3.3a.\n\nChoices: off, on, always.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` extended-keys-format `\n\nchoice; scope server; since 3.5.\n\nChoices: csi-u, xterm.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c)\n\n\n\n- ` fill-character `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` focus-events `\n\nflag; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` focus-follows-mouse `\n\nflag; scope session; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` get-clipboard `\n\nchoice; scope server; since 3.7.\n\nChoices: off, buffer, request, both.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` history-file `\n\nstring; scope server; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` history-limit `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` initial-repeat-time `\n\nnumber; scope session; since 3.6.\n\n\n\nRange: 0 through 2000000.\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` input-buffer-size `\n\nnumber; scope server; since 3.6.\n\n\n\nRange: 1048576 through 4294967295.\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` key-table `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` light-theme-black `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-blue `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-cyan `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-dark-grey `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-green `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-light-grey `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-magenta `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-red `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-white `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` light-theme-yellow `\n\nstring; scope server; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` lock-after-time `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` lock-command `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` main-pane-height `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` main-pane-width `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` marked-pane-changed `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` menu-border-lines `\n\nchoice; scope window; since 3.4.\n\nChoices: single, double, heavy, simple, rounded, padded, none.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` menu-border-style `\n\nstring; scope window; since 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` menu-selected-style `\n\nstring; scope window; since 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` menu-style `\n\nstring; scope window; since 3.4.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` message-command-style `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` message-format `\n\nstring; scope session; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` message-limit `\n\nnumber; scope server; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` message-line `\n\nchoice; scope session; since 3.4.\n\nChoices: 0, 1, 2, 3, 4.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c)\n\n\n\n- ` message-style `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` mode-keys `\n\nchoice; scope window; since 3.3a.\n\nChoices: emacs, vi.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` mode-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` monitor-activity `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` monitor-bell `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` monitor-silence `\n\nnumber; scope window; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` mouse `\n\nflag; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` other-pane-height `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` other-pane-width `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-active-border-style `\n\nstring; scope window; since 3.3a, before 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-active-border-style `\n\nstring; scope window, pane; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` pane-activity `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-base-index `\n\nnumber; scope window; since 3.3a.\n\n\n\nRange: 0 through 65535.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-bell `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-border-format `\n\nstring; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-border-indicators `\n\nchoice; scope window; since 3.3a.\n\nChoices: off, colour, arrows, both.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-border-lines `\n\nchoice; scope window; since 3.3a, before 3.6.\n\nChoices: single, double, heavy, simple, number.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-border-lines `\n\nchoice; scope window; since 3.6, before 3.8.\n\nChoices: single, double, heavy, simple, number, spaces.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-border-lines `\n\nchoice; scope window, pane; since 3.8.\n\nChoices: single, double, heavy, simple, number, spaces, none.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-border-status `\n\nchoice; scope window; since 3.3a, before 3.8.\n\nChoices: off, top, bottom.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-border-status `\n\nchoice; scope window, pane; since 3.8.\n\nChoices: off, top, bottom, top-floating, bottom-floating.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-border-style `\n\nstring; scope window; since 3.3a, before 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-border-style `\n\nstring; scope window, pane; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` pane-colours `\n\ncolour; scope window, pane; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-command-finished `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-command-started `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-created `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-died `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-exited `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-focus-in `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-focus-out `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-mode-changed `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-mode-entered `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-mode-exited `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-moved `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-prompt-closed `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-prompt-opened `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-resized `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-scrollbars `\n\nchoice; scope window; since 3.6, before 3.8.\n\nChoices: off, modal, on.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-scrollbars `\n\nchoice; scope window; since 3.8.\n\nChoices: off, modal, on, auto-hide.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-scrollbars-position `\n\nchoice; scope window; since 3.6.\n\nChoices: right, left.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-scrollbars-style `\n\nstring; scope window, pane; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-scrollbars-timeout `\n\nnumber; scope window; since 3.8.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-set-clipboard `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` pane-shell-prompt `\n\ncommand; scope window, pane; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` pane-status-current-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-status-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` pane-title-changed `\n\ncommand; scope window, pane; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` popup-border-lines `\n\nchoice; scope window; since 3.3a.\n\nChoices: single, double, heavy, simple, rounded, padded, none.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` popup-border-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` popup-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` prefix `\n\nkey; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` prefix-timeout `\n\nnumber; scope server; since 3.5.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c)\n\n\n\n- ` prefix2 `\n\nkey; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` prompt-command-cursor-colour `\n\nstring; scope session; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` prompt-command-cursor-style `\n\nchoice; scope session; since 3.7.\n\nChoices: default, blinking-block, block, blinking-underline, underline, blinking-bar, bar.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` prompt-cursor-colour `\n\ncolour; scope session; since 3.6, before 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` prompt-cursor-colour `\n\nstring; scope session; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` prompt-cursor-style `\n\nchoice; scope session; since 3.6.\n\nChoices: default, blinking-block, block, blinking-underline, underline, blinking-bar, bar.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` prompt-history-limit `\n\nnumber; scope server; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` remain-on-exit `\n\nchoice; scope window, pane; since 3.3a, before 3.7.\n\nChoices: off, on, failed.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` remain-on-exit `\n\nchoice; scope window, pane; since 3.7, before 3.8.\n\nChoices: off, on, failed, key.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` remain-on-exit `\n\nchoice; scope window, pane; since 3.8.\n\nChoices: off, on, failed, key, failed-key.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` remain-on-exit-format `\n\nstring; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` renumber-windows `\n\nflag; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` repeat-time `\n\nnumber; scope session; since 3.3a, before 3.6.\n\n\n\nRange: 0 through 32767.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` repeat-time `\n\nnumber; scope session; since 3.6.\n\n\n\nRange: 0 through 2000000.\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` scroll-on-clear `\n\nflag; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` session-added-to-group `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` session-closed `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` session-created `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` session-removed-from-group `\n\ncommand; scope session; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` session-renamed `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` session-status-current-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` session-status-style `\n\nstring; scope window; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` session-window-changed `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` set-clipboard `\n\nchoice; scope server; since 3.3a.\n\nChoices: off, external, on.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` set-titles `\n\nflag; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` set-titles-string `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` silence-action `\n\nchoice; scope session; since 3.3a.\n\nChoices: none, any, current, other.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status `\n\nchoice; scope session; since 3.3a.\n\nChoices: off, on, 2, 3, 4, 5.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-bg `\n\ncolour; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-fg `\n\ncolour; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-format `\n\nstring; scope session; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-interval `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 2147483647.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-justify `\n\nchoice; scope session; since 3.3a.\n\nChoices: left, centre, right, absolute-centre.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-keys `\n\nchoice; scope session; since 3.3a.\n\nChoices: emacs, vi.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-left `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-left-length `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 32767.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-left-style `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-position `\n\nchoice; scope session; since 3.3a.\n\nChoices: top, bottom.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-right `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-right-length `\n\nnumber; scope session; since 3.3a.\n\n\n\nRange: 0 through 32767.\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-right-style `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` status-style `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` switch-mode-match-style `\n\nstring; scope window, pane; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` synchronize-panes `\n\nflag; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` terminal-features `\n\nstring; scope server; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` terminal-overrides `\n\nstring; scope server; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` theme `\n\nchoice; scope server; since 3.8.\n\nChoices: detect, terminal, light, dark.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` tiled-layout-max-columns `\n\nnumber; scope window; since 3.6.\n\n\n\nRange: 0 through 65535.\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` tree-mode-border-style `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` tree-mode-preview-format `\n\nstring; scope window, pane; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` tree-mode-preview-style `\n\nstring; scope window; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` tree-mode-selection-style `\n\nstring; scope window; since 3.8.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` update-environment `\n\nstring; scope session; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` user-keys `\n\nstring; scope server; since 3.3a. Array.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` variation-selector-always-wide `\n\nflag; scope server; since 3.6.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c)\n\n\n\n- ` visual-activity `\n\nchoice; scope session; since 3.3a.\n\nChoices: off, on, both.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` visual-bell `\n\nchoice; scope session; since 3.3a.\n\nChoices: off, on, both.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` visual-silence `\n\nchoice; scope session; since 3.3a.\n\nChoices: off, on, both.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-active-style `\n\nstring; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-closed `\n\ncommand; scope window; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` window-created `\n\ncommand; scope window; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` window-layout-changed `\n\ncommand; scope window; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-linked `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-pane-changed `\n\ncommand; scope window; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-pane-current-status-format `\n\nstring; scope window; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` window-pane-status-format `\n\nstring; scope window; since 3.7.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c)\n\n\n\n- ` window-renamed `\n\ncommand; scope window; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-resized `\n\ncommand; scope window; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-size `\n\nchoice; scope window; since 3.3a.\n\nChoices: largest, smallest, manual, latest.\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-activity-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-bell-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-current-format `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-current-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-format `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-last-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-separator `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-status-style `\n\nstring; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-style `\n\nstring; scope window, pane; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-unlinked `\n\ncommand; scope session; since 3.3a. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` window-unzoomed `\n\ncommand; scope window; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` window-zoomed `\n\ncommand; scope window; since 3.8. Array. Hook.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c](https://github.com/tmux/tmux/blob/7f2a35ad3321f9ba57a1062ca73b1f3ff26aca53/options-table.c)\n\n\n\n- ` word-separators `\n\nstring; scope session; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` wrap-search `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)\n\n\n\n- ` xterm-keys `\n\nflag; scope window; since 3.3a.\n\n\n\n\n\nSource: [https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c)","summary":"Packaged, source-qualified fields, relationships, options and release profiles."},"id":"LibTmux::Catalogue","kind":"module","modifiers":[],"name":"Catalogue","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Catalogue","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue"},{"apiScope":"exported","doc":{"body":"Return the validated packaged catalogue; no tmux command is executed.","summary":"Return the validated packaged catalogue; no tmux command is executed."},"id":"LibTmux::Catalogue.catalogue","kind":"function","modifiers":[],"name":"catalogue","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue.catalogue","signatures":[{"params":[],"raw":"sub catalogue(--> CatalogueData:D)","references":[{"end":33,"start":18,"target":"LibTmux::Catalogue::CatalogueData"}],"returns":"CatalogueData:D","nativeSyntax":[{"start":4,"end":13,"kind":"name"}],"nativeSpans":[{"text":"sub "},{"text":"catalogue","declaration":true},{"text":"(--> "},{"text":"CatalogueData:D","target":"LibTmux::Catalogue::CatalogueData"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":459,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-catalogue"},{"apiScope":"exported","doc":{"body":"Preserve the raw string and reject vendor/development suffixes as unqualified.","summary":"Preserve the raw string and reject vendor/development suffixes as unqualified."},"id":"LibTmux::Catalogue.parse-tmux-version","kind":"function","modifiers":[],"name":"parse-tmux-version","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue.parse-tmux-version","signatures":[{"params":[{"keywordOnly":false,"name":"$raw","optional":false,"type":"Str:D"}],"raw":"sub parse-tmux-version(Str:D $raw --> TmuxVersion:D)","references":[{"end":51,"start":38,"target":"LibTmux::Catalogue::TmuxVersion"}],"returns":"TmuxVersion:D","nativeSyntax":[{"start":4,"end":22,"kind":"name"}],"nativeSpans":[{"text":"sub "},{"text":"parse-tmux-version","declaration":true},{"text":"(Str:D $raw --> "},{"text":"TmuxVersion:D","target":"LibTmux::Catalogue::TmuxVersion"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":38,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-parse-tmux-version"},{"apiScope":"exported","doc":{"body":"Return the immutable release policy without reading configuration or contacting tmux.","summary":"Return the immutable release policy without reading configuration or contacting tmux."},"id":"LibTmux::Catalogue.support-policy","kind":"function","modifiers":[],"name":"support-policy","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue.support-policy","signatures":[{"params":[],"raw":"sub support-policy(--> SupportPolicy:D)","references":[{"end":38,"start":23,"target":"LibTmux::Catalogue::SupportPolicy"}],"returns":"SupportPolicy:D","nativeSyntax":[{"start":4,"end":18,"kind":"name"}],"nativeSpans":[{"text":"sub "},{"text":"support-policy","declaration":true},{"text":"(--> "},{"text":"SupportPolicy:D","target":"LibTmux::Catalogue::SupportPolicy"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":203,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-support-policy"},{"apiScope":"exported","doc":{"body":"Typed schema lookup used by acquisition, local criteria and documentation.","summary":"Typed schema lookup used by acquisition, local criteria and documentation."},"id":"LibTmux::Catalogue::CatalogueData","kind":"class","modifiers":[],"name":"CatalogueData","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue::CatalogueData","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":209,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata"},{"apiScope":"exported","doc":{"body":"Read-only feature and defect policies with upstream provenance.","summary":"Read-only feature and defect policies with upstream provenance."},"id":"LibTmux::Catalogue::CatalogueData.all-capabilities","kind":"property","modifiers":[],"name":"all-capabilities","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.all-capabilities","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":215,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-cataloguedata-all-capabilities"},{"apiScope":"exported","doc":{"body":"Read-only field records across all registered entity schemas.","summary":"Read-only field records across all registered entity schemas."},"id":"LibTmux::Catalogue::CatalogueData.all-fields","kind":"property","modifiers":[],"name":"all-fields","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.all-fields","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":211,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-cataloguedata-all-fields"},{"apiScope":"exported","doc":{"body":"All option variants; use options(release) to select a qualified profile.","summary":"All option variants; use options(release) to select a qualified profile."},"id":"LibTmux::Catalogue::CatalogueData.all-options","kind":"property","modifiers":[],"name":"all-options","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.all-options","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":217,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-cataloguedata-all-options"},{"apiScope":"exported","doc":{"body":"Read-only graph relation records, independent of snapshot completeness.","summary":"Read-only graph relation records, independent of snapshot completeness."},"id":"LibTmux::Catalogue::CatalogueData.all-relations","kind":"property","modifiers":[],"name":"all-relations","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.all-relations","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":213,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-cataloguedata-all-relations"},{"apiScope":"exported","doc":{"body":"Feature policy or Nil; defect identifiers belong to workaround.","summary":"Feature policy or Nil; defect identifiers belong to workaround."},"id":"LibTmux::Catalogue::CatalogueData.capability","kind":"method","modifiers":[],"name":"capability","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.capability","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method capability(Str:D $id)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capability","declaration":true},{"text":"(Str:D $id)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":246,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-capability"},{"apiScope":"exported","doc":{"body":"Registered schema names in catalogue order, without duplicates.","summary":"Registered schema names in catalogue order, without duplicates."},"id":"LibTmux::Catalogue::CatalogueData.entities","kind":"method","modifiers":[],"name":"entities","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.entities","signatures":[{"params":[],"raw":"method entities(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entities","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":220,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-entities"},{"apiScope":"exported","doc":{"body":"One field record or Nil; an unknown entity schema throws InvalidFilter.","summary":"One field record or Nil; an unknown entity schema throws InvalidFilter."},"id":"LibTmux::Catalogue::CatalogueData.field","kind":"method","modifiers":[],"name":"field","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.field","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method field(Str:D $entity, Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"field","declaration":true},{"text":"(Str:D $entity, Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":236,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-field"},{"apiScope":"exported","doc":{"body":"Registered field records; an unknown entity schema throws InvalidFilter.","summary":"Registered field records; an unknown entity schema throws InvalidFilter."},"id":"LibTmux::Catalogue::CatalogueData.fields","kind":"method","modifiers":[],"name":"fields","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.fields","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method fields(Str:D $entity --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"fields","declaration":true},{"text":"(Str:D $entity --> List:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":226,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-fields"},{"apiScope":"exported","doc":{"body":"Whether a schema is registered, without inspecting any captured entities.","summary":"Whether a schema is registered, without inspecting any captured entities."},"id":"LibTmux::Catalogue::CatalogueData.has-entity","kind":"method","modifiers":[],"name":"has-entity","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.has-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method has-entity(Str:D $entity --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"has-entity","declaration":true},{"text":"(Str:D $entity --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":222,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-has-entity"},{"apiScope":"exported","doc":{"body":"One active option variant, or Nil for an unknown option or unqualified release.","summary":"One active option variant, or Nil for an unknown option or unqualified release."},"id":"LibTmux::Catalogue::CatalogueData.option","kind":"method","modifiers":[],"name":"option","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.option","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$release","optional":false,"type":"Str:D"}],"raw":"method option(Str:D $name, Str:D $release)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"option","declaration":true},{"text":"(Str:D $name, Str:D $release)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":263,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-option"},{"apiScope":"exported","doc":{"body":"Active option variants for an exact support profile; empty for an unqualified release.","summary":"Active option variants for an exact support profile; empty for an unqualified release."},"id":"LibTmux::Catalogue::CatalogueData.options","kind":"method","modifiers":[],"name":"options","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.options","signatures":[{"params":[{"keywordOnly":false,"name":"$release","optional":false,"type":"Str:D"}],"raw":"method options(Str:D $release --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"options","declaration":true},{"text":"(Str:D $release --> List:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":254,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-options"},{"apiScope":"exported","doc":{"body":"One relation record or Nil; an unknown entity schema throws InvalidFilter.","summary":"One relation record or Nil; an unknown entity schema throws InvalidFilter."},"id":"LibTmux::Catalogue::CatalogueData.relation","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $entity, Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $entity, Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":241,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-relation"},{"apiScope":"exported","doc":{"body":"Registered relation records; an unknown entity schema throws InvalidFilter.","summary":"Registered relation records; an unknown entity schema throws InvalidFilter."},"id":"LibTmux::Catalogue::CatalogueData.relations","kind":"method","modifiers":[],"name":"relations","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.relations","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method relations(Str:D $entity --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relations","declaration":true},{"text":"(Str:D $entity --> List:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":231,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-relations"},{"apiScope":"exported","doc":{"body":"Defect policy or Nil, without claiming that handling has occurred.","summary":"Defect policy or Nil, without claiming that handling has occurred."},"id":"LibTmux::Catalogue::CatalogueData.workaround","kind":"method","modifiers":[],"name":"workaround","package":"LibTmux","parent":"LibTmux::Catalogue::CatalogueData","product":"core","publicId":"LibTmux::Catalogue::CatalogueData.workaround","signatures":[{"params":[{"keywordOnly":false,"name":"$id","optional":false,"type":"Str:D"}],"raw":"method workaround(Str:D $id)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"workaround","declaration":true},{"text":"(Str:D $id)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":250,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-cataloguedata-workaround"},{"apiScope":"exported","doc":{"body":"One source-qualified option type, scope and operand range.","summary":"One source-qualified option type, scope and operand range."},"id":"LibTmux::Catalogue::OptionSpec","kind":"class","modifiers":[],"name":"OptionSpec","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue::OptionSpec","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":103,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-optionspec"},{"apiScope":"exported","doc":{"body":"Exclusive ending profile; empty when this variant has no declared end.","summary":"Exclusive ending profile; empty when this variant has no declared end."},"id":"LibTmux::Catalogue::OptionSpec.before","kind":"property","modifiers":[],"name":"before","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.before","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":111,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-optionspec-before"},{"apiScope":"exported","doc":{"body":"Closed native choice vocabulary; empty for other operand categories.","summary":"Closed native choice vocabulary; empty for other operand categories."},"id":"LibTmux::Catalogue::OptionSpec.choices","kind":"property","modifiers":[],"name":"choices","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.choices","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":117,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-optionspec-choices"},{"apiScope":"exported","doc":{"body":"Whether callers must address individual numeric array elements.","summary":"Whether callers must address individual numeric array elements."},"id":"LibTmux::Catalogue::OptionSpec.is-array","kind":"property","modifiers":[],"name":"is-array","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.is-array","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":119,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-catalogue-optionspec-is-array"},{"apiScope":"exported","doc":{"body":"Whether the option stores hook command lists.","summary":"Whether the option stores hook command lists."},"id":"LibTmux::Catalogue::OptionSpec.is-hook","kind":"property","modifiers":[],"name":"is-hook","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.is-hook","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":121,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-catalogue-optionspec-is-hook"},{"apiScope":"exported","doc":{"body":"Whether string values use tmux style syntax.","summary":"Whether string values use tmux style syntax."},"id":"LibTmux::Catalogue::OptionSpec.is-style","kind":"property","modifiers":[],"name":"is-style","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.is-style","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":123,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-catalogue-optionspec-is-style"},{"apiScope":"exported","doc":{"body":"Native operand category used by typed option validation and decoding.","summary":"Native operand category used by typed option validation and decoding."},"id":"LibTmux::Catalogue::OptionSpec.kind","kind":"property","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.kind","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":107,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-optionspec-kind"},{"apiScope":"exported","doc":{"body":"Highest accepted integer in the option's native units; undefined outside numeric schemas.","summary":"Highest accepted integer in the option's native units; undefined outside numeric schemas."},"id":"LibTmux::Catalogue::OptionSpec.maximum","kind":"property","modifiers":[],"name":"maximum","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.maximum","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":127,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-catalogue-optionspec-maximum"},{"apiScope":"exported","doc":{"body":"Lowest accepted integer in the option's native units; undefined outside numeric schemas.","summary":"Lowest accepted integer in the option's native units; undefined outside numeric schemas."},"id":"LibTmux::Catalogue::OptionSpec.minimum","kind":"property","modifiers":[],"name":"minimum","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.minimum","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":125,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-catalogue-optionspec-minimum"},{"apiScope":"exported","doc":{"body":"Native option name, without an array index.","summary":"Native option name, without an array index."},"id":"LibTmux::Catalogue::OptionSpec.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.name","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":105,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-optionspec-name"},{"apiScope":"exported","doc":{"body":"Permitted server, session, window or pane scopes; membership is read-only.","summary":"Permitted server, session, window or pane scopes; membership is read-only."},"id":"LibTmux::Catalogue::OptionSpec.scopes","kind":"property","modifiers":[],"name":"scopes","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.scopes","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":115,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-optionspec-scopes"},{"apiScope":"exported","doc":{"body":"First declared support profile using this exact option variant.","summary":"First declared support profile using this exact option variant."},"id":"LibTmux::Catalogue::OptionSpec.since","kind":"property","modifiers":[],"name":"since","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.since","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":109,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-optionspec-since"},{"apiScope":"exported","doc":{"body":"Pinned options-table.c source from which this variant was extracted.","summary":"Pinned options-table.c source from which this variant was extracted."},"id":"LibTmux::Catalogue::OptionSpec.source","kind":"property","modifiers":[],"name":"source","package":"LibTmux","parent":"LibTmux::Catalogue::OptionSpec","product":"core","publicId":"LibTmux::Catalogue::OptionSpec.source","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":113,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-optionspec-source"},{"apiScope":"exported","doc":{"body":"Ordered release profiles are the sole source of the floor and CI endpoints.","summary":"Ordered release profiles are the sole source of the floor and CI endpoints."},"id":"LibTmux::Catalogue::SupportPolicy","kind":"class","modifiers":[],"name":"SupportPolicy","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-supportpolicy"},{"apiScope":"exported","doc":{"body":"Oldest and newest profiles for required CI, deduplicated for a single release.","summary":"Oldest and newest profiles for required CI, deduplicated for a single release."},"id":"LibTmux::Catalogue::SupportPolicy.endpoints","kind":"method","modifiers":[],"name":"endpoints","package":"LibTmux","parent":"LibTmux::Catalogue::SupportPolicy","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy.endpoints","signatures":[{"params":[],"raw":"method endpoints(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"endpoints","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":166,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-supportpolicy-endpoints"},{"apiScope":"exported","doc":{"body":"Newest declared supported release, independent of unqualified future releases.","summary":"Newest declared supported release, independent of unqualified future releases."},"id":"LibTmux::Catalogue::SupportPolicy.latest","kind":"method","modifiers":[],"name":"latest","package":"LibTmux","parent":"LibTmux::Catalogue::SupportPolicy","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy.latest","signatures":[{"params":[],"raw":"method latest(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"latest","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":162,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-supportpolicy-latest"},{"apiScope":"exported","doc":{"body":"Oldest declared supported release; no older compatibility is inferred.","summary":"Oldest declared supported release; no older compatibility is inferred."},"id":"LibTmux::Catalogue::SupportPolicy.minimum","kind":"method","modifiers":[],"name":"minimum","package":"LibTmux","parent":"LibTmux::Catalogue::SupportPolicy","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy.minimum","signatures":[{"params":[],"raw":"method minimum(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"minimum","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":160,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-supportpolicy-minimum"},{"apiScope":"exported","doc":{"body":"Exact declared profile, or Nil for an undeclared spelling.","summary":"Exact declared profile, or Nil for an undeclared spelling."},"id":"LibTmux::Catalogue::SupportPolicy.profile","kind":"method","modifiers":[],"name":"profile","package":"LibTmux","parent":"LibTmux::Catalogue::SupportPolicy","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy.profile","signatures":[{"params":[{"keywordOnly":false,"name":"$version","optional":false,"type":"Str:D"}],"raw":"method profile(Str:D $version)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"profile","declaration":true},{"text":"(Str:D $version)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":164,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-supportpolicy-profile"},{"apiScope":"exported","doc":{"body":"Read-only profiles in strictly increasing release order, each with pinned source identity.","summary":"Read-only profiles in strictly increasing release order, each with pinned source identity."},"id":"LibTmux::Catalogue::SupportPolicy.releases","kind":"property","modifiers":[],"name":"releases","package":"LibTmux","parent":"LibTmux::Catalogue::SupportPolicy","product":"core","publicId":"LibTmux::Catalogue::SupportPolicy.releases","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":157,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-catalogue-supportpolicy-releases"},{"apiScope":"exported","doc":{"body":"Parsed release spelling; an exact release can still lack a support profile.","summary":"Parsed release spelling; an exact release can still lack a support profile."},"id":"LibTmux::Catalogue::TmuxVersion","kind":"class","modifiers":[],"name":"TmuxVersion","package":"LibTmux","parent":"LibTmux::Catalogue","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":10,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-tmuxversion"},{"apiScope":"exported","doc":{"body":"Compare stable release components, including tmux's letter suffix.","summary":"Compare stable release components, including tmux's letter suffix."},"id":"LibTmux::Catalogue::TmuxVersion.at-least","kind":"method","modifiers":[],"name":"at-least","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.at-least","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"TmuxVersion:D"}],"raw":"method at-least(TmuxVersion:D $other --> Bool:D)","references":[{"end":29,"start":16,"target":"LibTmux::Catalogue::TmuxVersion"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"at-least","declaration":true},{"text":"("},{"text":"TmuxVersion:D","target":"LibTmux::Catalogue::TmuxVersion"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-catalogue-tmuxversion-at-least"},{"apiScope":"exported","doc":{"body":"Numeric major component; zero for an unqualified spelling.","summary":"Numeric major component; zero for an unqualified spelling."},"id":"LibTmux::Catalogue::TmuxVersion.major","kind":"property","modifiers":[],"name":"major","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.major","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":18,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-catalogue-tmuxversion-major"},{"apiScope":"exported","doc":{"body":"Numeric minor component; zero for an unqualified spelling.","summary":"Numeric minor component; zero for an unqualified spelling."},"id":"LibTmux::Catalogue::TmuxVersion.minor","kind":"property","modifiers":[],"name":"minor","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.minor","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-catalogue-tmuxversion-minor"},{"apiScope":"exported","doc":{"body":"Original input, including any executable banner or unqualified suffix.","summary":"Original input, including any executable banner or unqualified suffix."},"id":"LibTmux::Catalogue::TmuxVersion.raw","kind":"property","modifiers":[],"name":"raw","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.raw","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":12,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-tmuxversion-raw"},{"apiScope":"exported","doc":{"body":"Release spelling without the optional tmux prefix; empty when unqualified.","summary":"Release spelling without the optional tmux prefix; empty when unqualified."},"id":"LibTmux::Catalogue::TmuxVersion.release","kind":"property","modifiers":[],"name":"release","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.release","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":14,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-tmuxversion-release"},{"apiScope":"exported","doc":{"body":"Whether the spelling is a stable release, independent of supported versions.","summary":"Whether the spelling is a stable release, independent of supported versions."},"id":"LibTmux::Catalogue::TmuxVersion.stable","kind":"property","modifiers":[],"name":"stable","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.stable","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-catalogue-tmuxversion-stable"},{"apiScope":"exported","doc":{"body":"Lowercase patch-release letter, or empty for a plain or unqualified release.","summary":"Lowercase patch-release letter, or empty for a plain or unqualified release."},"id":"LibTmux::Catalogue::TmuxVersion.suffix","kind":"property","modifiers":[],"name":"suffix","package":"LibTmux","parent":"LibTmux::Catalogue::TmuxVersion","product":"core","publicId":"LibTmux::Catalogue::TmuxVersion.suffix","signatures":[],"source":{"file":"lib/LibTmux/Catalogue.rakumod","line":22,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-catalogue-tmuxversion-suffix"},{"apiScope":"exported","doc":{"body":"# Client commands\n\nClientTarget retains endpoint and daemon identity values only. Each operation\nlists clients and checks the observed name, process ID and creation time before\ndispatch. tmux exposes no permanent client ID: disconnect and name reuse between\nthis check and the command remain possible. The daemon fence does not make that\ncheck atomic. A client target never silently selects a current client.\nThe read-only toggle follows tmux's paired read-only/ignore-size flag behavior;\nit retains the observed session and suppresses environment updates.\n\nPane-context UI methods require an explicit pane belonging to the client's\ncurrent session. This avoids display-message's missing-target fallback. Pane\nmodes are shared by every client viewing that pane, not private UI state.\n\nMenu, prompt, popup and pane-number methods return Promises and require an\nexplicit timeout in milliseconds. Human interaction may outlast that budget.\nCancellation or timeout stops the command client; it does not retract an overlay\nor command already submitted. Use close-popup explicitly when appropriate.\nResults describe command completion, not rendered pixels or a human response.\n\nLiteral messages disable FORMAT and strftime interpolation. tmux display styles\nstill apply. Menu labels retain display styles and leading-minus disabled-entry\nsemantics. CommandTemplate deliberately exposes tmux template syntax and percent\nsubstitutions; it is never compiled as Raku. Popup shell-command deliberately\nrequests shell execution. Other commands use argv and the shared tmux encoder.","summary":""},"id":"LibTmux::Client","kind":"module","modifiers":[],"name":"Client","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Client","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client"},{"apiScope":"exported","doc":{"body":"A value-only client target. No subprocess or connection is retained.","summary":"A value-only client target. No subprocess or connection is retained."},"id":"LibTmux::Client::ClientTarget","kind":"class","modifiers":[],"name":"ClientTarget","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::ClientTarget","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":70,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget"},{"apiScope":"exported","doc":{"body":"Enter a pane mode shared by every client viewing that pane.","summary":"Enter a pane mode shared by every client viewing that pane."},"id":"LibTmux::Client::ClientTarget.choose","kind":"method","modifiers":[],"name":"choose","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.choose","signatures":[{"params":[{"keywordOnly":false,"name":"$kind","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"Str","keywordOnly":true,"name":"$format","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$filter","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$key-format","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$sort","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$reverse","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$zoom","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$preview","optional":true,"type":"Bool:D"},{"default":"CommandTemplate","keywordOnly":true,"name":"$template","optional":true,"type":"CommandTemplate"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method choose(Str:D $kind, PaneId:D :$pane!, Str :$format = Str,\n                  Str :$filter = Str, Str :$key-format = Str, Str :$sort = Str,\n                  Bool:D :$reverse = False, Bool:D :$zoom = False,\n                  Bool:D :$preview = True, CommandTemplate :$template = CommandTemplate,\n                  *%operation --> Result:D)","references":[{"end":35,"start":27,"target":"LibTmux::Types::PaneId"},{"end":270,"start":255,"target":"LibTmux::Client::CommandTemplate"},{"end":299,"start":284,"target":"LibTmux::Client::CommandTemplate"},{"end":343,"start":335,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"choose","declaration":true},{"text":"(Str:D $kind, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Str :$format = Str,\n                  Str :$filter = Str, Str :$key-format = Str, Str :$sort = Str,\n                  Bool:D :$reverse = False, Bool:D :$zoom = False,\n                  Bool:D :$preview = True, "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":" :$template = "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":",\n                  *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":245,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-choose"},{"apiScope":"exported","doc":{"body":"Clear the daemon's selected prompt history; it is shared across clients.","summary":"Clear the daemon's selected prompt history; it is shared across clients."},"id":"LibTmux::Client::ClientTarget.clear-prompt-history","kind":"method","modifiers":[],"name":"clear-prompt-history","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.clear-prompt-history","signatures":[{"params":[{"default":"Str","keywordOnly":true,"name":"$type","optional":true,"type":"Str"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method clear-prompt-history(Str :$type = Str, *%operation --> Result:D)","references":[{"end":70,"start":62,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":27,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clear-prompt-history","declaration":true},{"text":"(Str :$type = Str, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":366,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-clear-prompt-history"},{"apiScope":"exported","doc":{"body":"Revalidate changed target values; this performs no existence check or I/O.","summary":"Revalidate changed target values; this performs no existence check or I/O."},"id":"LibTmux::Client::ClientTarget.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> ClientTarget:D)","references":[{"end":41,"start":27,"target":"LibTmux::Client::ClientTarget"}],"returns":"ClientTarget:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"ClientTarget:D","target":"LibTmux::Client::ClientTarget"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":89,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-clone"},{"apiScope":"exported","doc":{"body":"Explicitly remove the current popup/overlay, including one left after timeout.","summary":"Explicitly remove the current popup/overlay, including one left after timeout."},"id":"LibTmux::Client::ClientTarget.close-popup","kind":"method","modifiers":[],"name":"close-popup","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.close-popup","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method close-popup(*%operation --> Result:D)","references":[{"end":43,"start":35,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close-popup","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":212,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-close-popup"},{"apiScope":"exported","doc":{"body":"Ask confirmation before one Invocation. A refusal is returned as a Result.","summary":"Ask confirmation before one Invocation. A refusal is returned as a Result."},"id":"LibTmux::Client::ClientTarget.confirm-async","kind":"method","modifiers":[],"name":"confirm-async","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.confirm-async","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"'Confirm? (y/n)'","keywordOnly":true,"name":"$prompt","optional":true,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method confirm-async(Invocation:D $command, Positive:D :$timeout-ms!,\n                         Str:D :$prompt = 'Confirm? (y/n)', *%operation --> Promise:D)","references":[{"end":33,"start":21,"target":"LibTmux::Command::Invocation"},{"end":54,"start":44,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"confirm-async","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                         Str:D :$prompt = 'Confirm? (y/n)', *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":237,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-confirm-async"},{"apiScope":"exported","doc":{"body":"Observed tmux client creation timestamp in Unix seconds.","summary":"Observed tmux client creation timestamp in Unix seconds."},"id":"LibTmux::Client::ClientTarget.created","kind":"property","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.created","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":80,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-client-clienttarget-created"},{"apiScope":"exported","doc":{"body":"Request detachment of this exact observed client. Completion is not exit proof.","summary":"Request detachment of this exact observed client. Completion is not exit proof."},"id":"LibTmux::Client::ClientTarget.detach","kind":"method","modifiers":[],"name":"detach","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.detach","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method detach(*%operation --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"detach","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":313,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-detach"},{"apiScope":"exported","doc":{"body":"Evaluate explicit FORMAT and strftime syntax in an existing pane context.","summary":"Evaluate explicit FORMAT and strftime syntax in an existing pane context."},"id":"LibTmux::Client::ClientTarget.display-format","kind":"method","modifiers":[],"name":"display-format","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.display-format","signatures":[{"params":[{"keywordOnly":false,"name":"$format","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"True","keywordOnly":true,"name":"$print","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-format(Str:D $format, PaneId:D :$pane!, Bool:D :$print = True,\n                          *%operation --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Types::PaneId"},{"end":128,"start":120,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-format","declaration":true},{"text":"(Str:D $format, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Bool:D :$print = True,\n                          *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":146,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-display-format"},{"apiScope":"exported","doc":{"body":"Display literal FORMAT/time text; tmux still interprets display styles.","summary":"Display literal FORMAT/time text; tmux still interprets display styles."},"id":"LibTmux::Client::ClientTarget.display-message","kind":"method","modifiers":[],"name":"display-message","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.display-message","signatures":[{"params":[{"keywordOnly":false,"name":"$message","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"Count","keywordOnly":true,"name":"$duration-ms","optional":true,"type":"Count"},{"default":"False","keywordOnly":true,"name":"$print","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-message(Str:D $message, PaneId:D :$pane!, Count :$duration-ms = Count,\n                           Bool:D :$print = False, *%operation --> Result:D)","references":[{"end":47,"start":39,"target":"LibTmux::Types::PaneId"},{"end":62,"start":57,"target":"LibTmux::Types::Count"},{"end":84,"start":79,"target":"LibTmux::Types::Count"},{"end":161,"start":153,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-message","declaration":true},{"text":"(Str:D $message, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$duration-ms = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":",\n                           Bool:D :$print = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":136,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-display-message"},{"apiScope":"exported","doc":{"body":"Display pane numbers, with an optional explicit tmux selection template.","summary":"Display pane numbers, with an optional explicit tmux selection template."},"id":"LibTmux::Client::ClientTarget.display-panes-async","kind":"method","modifiers":[],"name":"display-panes-async","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.display-panes-async","signatures":[{"params":[{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"Count","keywordOnly":true,"name":"$duration-ms","optional":true,"type":"Count"},{"default":"True","keywordOnly":true,"name":"$select","optional":true,"type":"Bool:D"},{"default":"CommandTemplate","keywordOnly":true,"name":"$template","optional":true,"type":"CommandTemplate"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-panes-async(Positive:D :$timeout-ms!, Count :$duration-ms = Count,\n                               Bool:D :$select = True,\n                               CommandTemplate :$template = CommandTemplate,\n                               *%operation --> Promise:D)","references":[{"end":37,"start":27,"target":"LibTmux::Types::Positive"},{"end":58,"start":53,"target":"LibTmux::Types::Count"},{"end":80,"start":75,"target":"LibTmux::Types::Count"},{"end":183,"start":168,"target":"LibTmux::Client::CommandTemplate"},{"end":212,"start":197,"target":"LibTmux::Client::CommandTemplate"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":26,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-panes-async","declaration":true},{"text":"("},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!, "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$duration-ms = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":",\n                               Bool:D :$select = True,\n                               "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":" :$template = "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":",\n                               *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":287,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-display-panes-async"},{"apiScope":"exported","doc":{"body":"Socket and executable configuration; no active connection is retained.","summary":"Socket and executable configuration; no active connection is retained."},"id":"LibTmux::Client::ClientTarget.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":72,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-client-clienttarget-endpoint"},{"apiScope":"exported","doc":{"body":"Open the native finder using tmux match/FORMAT syntax, not literal substring data.","summary":"Open the native finder using tmux match/FORMAT syntax, not literal substring data."},"id":"LibTmux::Client::ClientTarget.find-window","kind":"method","modifiers":[],"name":"find-window","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.find-window","signatures":[{"params":[{"keywordOnly":false,"name":"$pattern","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"True","keywordOnly":true,"name":"$content","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$names","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$titles","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$regex","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$ignore-case","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$zoom","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method find-window(Str:D $pattern, PaneId:D :$pane!, Bool:D :$content = True,\n                       Bool:D :$names = True, Bool:D :$titles = True,\n                       Bool:D :$regex = False, Bool:D :$ignore-case = False,\n                       Bool:D :$zoom = False, *%operation --> Result:D)","references":[{"end":43,"start":35,"target":"LibTmux::Types::PaneId"},{"end":295,"start":287,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"find-window","declaration":true},{"text":"(Str:D $pattern, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Bool:D :$content = True,\n                       Bool:D :$names = True, Bool:D :$titles = True,\n                       Bool:D :$regex = False, Bool:D :$ignore-case = False,\n                       Bool:D :$zoom = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":269,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-find-window"},{"apiScope":"exported","doc":{"body":"Daemon identity checked before dispatching a client operation.","summary":"Daemon identity checked before dispatching a client operation."},"id":"LibTmux::Client::ClientTarget.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Incarnation:D","slug":"libtmux-client-clienttarget-incarnation"},{"apiScope":"exported","doc":{"body":"Select an existing key table; its name is passed without FORMAT expansion.","summary":"Select an existing key table; its name is passed without FORMAT expansion."},"id":"LibTmux::Client::ClientTarget.key-table","kind":"method","modifiers":[],"name":"key-table","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.key-table","signatures":[{"params":[{"keywordOnly":false,"name":"$table","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method key-table(Str:D $table, *%operation --> Result:D)","references":[{"end":55,"start":47,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"key-table","declaration":true},{"text":"(Str:D $table, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":337,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-key-table"},{"apiScope":"exported","doc":{"body":"Invoke the configured lock command for this client.","summary":"Invoke the configured lock command for this client."},"id":"LibTmux::Client::ClientTarget.lock","kind":"method","modifiers":[],"name":"lock","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.lock","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method lock(*%operation --> Result:D)","references":[{"end":36,"start":28,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"lock","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":323,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-lock"},{"apiScope":"exported","doc":{"body":"Show a menu. Completion follows tmux's command lifecycle, not rendering proof.","summary":"Show a menu. Completion follows tmux's command lifecycle, not rendering proof."},"id":"LibTmux::Client::ClientTarget.menu-async","kind":"method","modifiers":[],"name":"menu-async","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.menu-async","signatures":[{"params":[{"keywordOnly":false,"name":"$items","optional":false,"type":"Positional:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"''","keywordOnly":true,"name":"$title","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$x","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$y","optional":true,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$stay-open","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$mouse","optional":true,"type":"Bool:D"},{"default":"Str","keywordOnly":true,"name":"$style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$border-style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$selected-style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$border-lines","optional":true,"type":"Str"},{"default":"Count","keywordOnly":true,"name":"$starting-choice","optional":true,"type":"Count"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method menu-async(Positional:D $items, PaneId:D :$pane!, Positive:D :$timeout-ms!,\n                      Str:D :$title = '', Str:D :$x = 'C', Str:D :$y = 'C',\n                      Bool:D :$stay-open = False, Bool:D :$mouse = False,\n                      Str :$style = Str, Str :$border-style = Str,\n                      Str :$selected-style = Str, Str :$border-lines = Str,\n                      Count :$starting-choice = Count, *%operation --> Promise:D)","references":[{"end":47,"start":39,"target":"LibTmux::Types::PaneId"},{"end":67,"start":57,"target":"LibTmux::Types::Positive"},{"end":403,"start":398,"target":"LibTmux::Types::Count"},{"end":429,"start":424,"target":"LibTmux::Types::Count"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"menu-async","declaration":true},{"text":"(Positional:D $items, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                      Str:D :$title = '', Str:D :$x = 'C', Str:D :$y = 'C',\n                      Bool:D :$stay-open = False, Bool:D :$mouse = False,\n                      Str :$style = Str, Str :$border-style = Str,\n                      Str :$selected-style = Str, Str :$border-lines = Str,\n                      "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$starting-choice = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":", *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-menu-async"},{"apiScope":"exported","doc":{"body":"Observed client name decoded with utf8-c8 to preserve target bytes.","summary":"Observed client name decoded with utf8-c8 to preserve target bytes."},"id":"LibTmux::Client::ClientTarget.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.name","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":76,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-client-clienttarget-name"},{"apiScope":"exported","doc":{"body":"Observed client process ID, checked together with name and creation time.","summary":"Observed client process ID, checked together with name and creation time."},"id":"LibTmux::Client::ClientTarget.pid","kind":"property","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.pid","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-client-clienttarget-pid"},{"apiScope":"exported","doc":{"body":"Start an explicitly supplied shell command in a popup; wait asynchronously.","summary":"Start an explicitly supplied shell command in a popup; wait asynchronously."},"id":"LibTmux::Client::ClientTarget.popup-async","kind":"method","modifiers":[],"name":"popup-async","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.popup-async","signatures":[{"params":[{"keywordOnly":true,"name":"$shell-command","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"''","keywordOnly":true,"name":"$title","optional":true,"type":"Str:D"},{"default":"Str","keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"default":"Positive","keywordOnly":true,"name":"$width","optional":true,"type":"Positive"},{"default":"Positive","keywordOnly":true,"name":"$height","optional":true,"type":"Positive"},{"default":"'C'","keywordOnly":true,"name":"$x","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$y","optional":true,"type":"Str:D"},{"default":"'exit'","keywordOnly":true,"name":"$close","optional":true,"type":"Str:D"},{"default":"True","keywordOnly":true,"name":"$border","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$close-on-key","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$reset-flags","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method popup-async(Str:D :$shell-command!, PaneId:D :$pane!, Positive:D :$timeout-ms!,\n                       Str:D :$title = '', Str :$directory = Str,\n                       Positive :$width = Positive, Positive :$height = Positive,\n                       Str:D :$x = 'C', Str:D :$y = 'C',\n                       Str:D :$close = 'exit', Bool:D :$border = True,\n                       Bool:D :$close-on-key = False, Bool:D :$reset-flags = False,\n                       *%operation --> Promise:D)","references":[{"end":51,"start":43,"target":"LibTmux::Types::PaneId"},{"end":71,"start":61,"target":"LibTmux::Types::Positive"},{"end":184,"start":176,"target":"LibTmux::Types::Positive"},{"end":203,"start":195,"target":"LibTmux::Types::Positive"},{"end":213,"start":205,"target":"LibTmux::Types::Positive"},{"end":233,"start":225,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"popup-async","declaration":true},{"text":"(Str:D :$shell-command!, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                       Str:D :$title = '', Str :$directory = Str,\n                       "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$width = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$height = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":",\n                       Str:D :$x = 'C', Str:D :$y = 'C',\n                       Str:D :$close = 'exit', Bool:D :$border = True,\n                       Bool:D :$close-on-key = False, Bool:D :$reset-flags = False,\n                       *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":188,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-popup-async"},{"apiScope":"exported","doc":{"body":"Prompt with explicit tmux template syntax. Commas separate prompts and inputs.","summary":"Prompt with explicit tmux template syntax. Commas separate prompts and inputs."},"id":"LibTmux::Client::ClientTarget.prompt-async","kind":"method","modifiers":[],"name":"prompt-async","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.prompt-async","signatures":[{"params":[{"keywordOnly":false,"name":"$template","optional":false,"type":"CommandTemplate:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"':'","keywordOnly":true,"name":"$prompts","optional":true,"type":"Str:D"},{"default":"''","keywordOnly":true,"name":"$inputs","optional":true,"type":"Str:D"},{"default":"'text'","keywordOnly":true,"name":"$mode","optional":true,"type":"Str:D"},{"default":"'command'","keywordOnly":true,"name":"$type","optional":true,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$literal-commas","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method prompt-async(CommandTemplate:D $template, Positive:D :$timeout-ms!,\n                        Str:D :$prompts = ':', Str:D :$inputs = '',\n                        Str:D :$mode = 'text', Str:D :$type = 'command',\n                        Bool:D :$literal-commas = False,\n                        *%operation --> Promise:D)","references":[{"end":37,"start":20,"target":"LibTmux::Client::CommandTemplate"},{"end":59,"start":49,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"prompt-async","declaration":true},{"text":"("},{"text":"CommandTemplate:D","target":"LibTmux::Client::CommandTemplate"},{"text":" $template, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                        Str:D :$prompts = ':', Str:D :$inputs = '',\n                        Str:D :$mode = 'text', Str:D :$type = 'command',\n                        Bool:D :$literal-commas = False,\n                        *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":217,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-prompt-async"},{"apiScope":"exported","doc":{"body":"Return raw prompt-history output, without claiming newline-safe entry framing.","summary":"Return raw prompt-history output, without claiming newline-safe entry framing."},"id":"LibTmux::Client::ClientTarget.prompt-history","kind":"method","modifiers":[],"name":"prompt-history","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.prompt-history","signatures":[{"params":[{"default":"Str","keywordOnly":true,"name":"$type","optional":true,"type":"Str"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method prompt-history(Str :$type = Str, *%operation --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"prompt-history","declaration":true},{"text":"(Str :$type = Str, *%operation --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":359,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-prompt-history"},{"apiScope":"exported","doc":{"body":"Refresh the display, status, or viewport using one explicit action.","summary":"Refresh the display, status, or viewport using one explicit action."},"id":"LibTmux::Client::ClientTarget.refresh","kind":"method","modifiers":[],"name":"refresh","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.refresh","signatures":[{"params":[{"default":"'all'","keywordOnly":true,"name":"$part","optional":true,"type":"Str:D"},{"default":"Positive","keywordOnly":true,"name":"$amount","optional":true,"type":"Positive"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method refresh(Str:D :$part = 'all', Positive :$amount = Positive,\n                   *%operation --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Types::Positive"},{"end":65,"start":57,"target":"LibTmux::Types::Positive"},{"end":110,"start":102,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"refresh","declaration":true},{"text":"(Str:D :$part = 'all', "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$amount = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":",\n                   *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":299,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-refresh"},{"apiScope":"exported","doc":{"body":"Suspend the client's terminal process through tmux.","summary":"Suspend the client's terminal process through tmux."},"id":"LibTmux::Client::ClientTarget.suspend","kind":"method","modifiers":[],"name":"suspend","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.suspend","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method suspend(*%operation --> Result:D)","references":[{"end":39,"start":31,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"suspend","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":318,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-suspend"},{"apiScope":"exported","doc":{"body":"Switch session by ID. Updating the session environment is opt-in.","summary":"Switch session by ID. Updating the session environment is opt-in."},"id":"LibTmux::Client::ClientTarget.switch","kind":"method","modifiers":[],"name":"switch","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.switch","signatures":[{"params":[{"keywordOnly":false,"name":"$session","optional":false,"type":"SessionId:D"},{"default":"False","keywordOnly":true,"name":"$update-environment","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$keep-zoom","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method switch(SessionId:D $session, Bool:D :$update-environment = False,\n                  Bool:D :$keep-zoom = False, *%operation --> Result:D)","references":[{"end":25,"start":14,"target":"LibTmux::Types::SessionId"},{"end":143,"start":135,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"switch","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" $session, Bool:D :$update-environment = False,\n                  Bool:D :$keep-zoom = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":328,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-switch"},{"apiScope":"exported","doc":{"body":"Switch relative to this client's current/previous session.","summary":"Switch relative to this client's current/previous session."},"id":"LibTmux::Client::ClientTarget.switch-relative","kind":"method","modifiers":[],"name":"switch-relative","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.switch-relative","signatures":[{"params":[{"keywordOnly":false,"name":"$direction","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method switch-relative(Str:D $direction, *%operation --> Result:D)","references":[{"end":65,"start":57,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"switch-relative","declaration":true},{"text":"(Str:D $direction, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":344,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-switch-relative"},{"apiScope":"exported","doc":{"body":"Toggle read-only and ignore-size flags while retaining the observed session.","summary":"Toggle read-only and ignore-size flags while retaining the observed session."},"id":"LibTmux::Client::ClientTarget.toggle-read-only","kind":"method","modifiers":[],"name":"toggle-read-only","package":"LibTmux","parent":"LibTmux::Client::ClientTarget","product":"core","publicId":"LibTmux::Client::ClientTarget.toggle-read-only","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method toggle-read-only(*%operation --> Result:D)","references":[{"end":48,"start":40,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":23,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"toggle-read-only","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":353,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-clienttarget-toggle-read-only"},{"apiScope":"exported","doc":{"body":"Explicit tmux command-template syntax, including percent substitutions.","summary":"Explicit tmux command-template syntax, including percent substitutions."},"id":"LibTmux::Client::CommandTemplate","kind":"class","modifiers":[],"name":"CommandTemplate","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::CommandTemplate","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-commandtemplate"},{"apiScope":"exported","doc":{"body":"Revalidate replacement source without executing the template.","summary":"Revalidate replacement source without executing the template."},"id":"LibTmux::Client::CommandTemplate.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Client::CommandTemplate","product":"core","publicId":"LibTmux::Client::CommandTemplate.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> CommandTemplate:D)","references":[{"end":44,"start":27,"target":"LibTmux::Client::CommandTemplate"}],"returns":"CommandTemplate:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"CommandTemplate:D","target":"LibTmux::Client::CommandTemplate"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-commandtemplate-clone"},{"apiScope":"exported","doc":{"body":"Unescaped tmux command-template syntax, including native percent placeholders.","summary":"Unescaped tmux command-template syntax, including native percent placeholders."},"id":"LibTmux::Client::CommandTemplate.source","kind":"property","modifiers":[],"name":"source","package":"LibTmux","parent":"LibTmux::Client::CommandTemplate","product":"core","publicId":"LibTmux::Client::CommandTemplate.source","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":22,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-client-commandtemplate-source"},{"apiScope":"exported","doc":{"body":"A menu entry. Empty labels are separators; labels retain tmux display styles.","summary":"A menu entry. Empty labels are separators; labels retain tmux display styles."},"id":"LibTmux::Client::MenuItem","kind":"class","modifiers":[],"name":"MenuItem","package":"LibTmux","parent":"LibTmux::Client","product":"core","publicId":"LibTmux::Client::MenuItem","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-menuitem"},{"apiScope":"exported","doc":{"body":"Revalidate a modified entry, including separator and command consistency.","summary":"Revalidate a modified entry, including separator and command consistency."},"id":"LibTmux::Client::MenuItem.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Client::MenuItem","product":"core","publicId":"LibTmux::Client::MenuItem.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> MenuItem:D)","references":[{"end":37,"start":27,"target":"LibTmux::Client::MenuItem"}],"returns":"MenuItem:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"MenuItem:D","target":"LibTmux::Client::MenuItem"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-client-menuitem-clone"},{"apiScope":"exported","doc":{"body":"Command executed on selection; undefined only for a separator.","summary":"Command executed on selection; undefined only for a separator."},"id":"LibTmux::Client::MenuItem.command","kind":"property","modifiers":[],"name":"command","package":"LibTmux","parent":"LibTmux::Client::MenuItem","product":"core","publicId":"LibTmux::Client::MenuItem.command","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":38,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Invocation","slug":"libtmux-client-menuitem-command"},{"apiScope":"exported","doc":{"body":"Render an unavailable item whose command cannot be selected.","summary":"Render an unavailable item whose command cannot be selected."},"id":"LibTmux::Client::MenuItem.disabled","kind":"property","modifiers":[],"name":"disabled","package":"LibTmux","parent":"LibTmux::Client::MenuItem","product":"core","publicId":"LibTmux::Client::MenuItem.disabled","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":40,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-client-menuitem-disabled"},{"apiScope":"exported","doc":{"body":"Native tmux key name; empty text leaves the item without a shortcut.","summary":"Native tmux key name; empty text leaves the item without a shortcut."},"id":"LibTmux::Client::MenuItem.key","kind":"property","modifiers":[],"name":"key","package":"LibTmux","parent":"LibTmux::Client::MenuItem","product":"core","publicId":"LibTmux::Client::MenuItem.key","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-client-menuitem-key"},{"apiScope":"exported","doc":{"body":"Display text with tmux styles retained; an empty label creates a separator.","summary":"Display text with tmux styles retained; an empty label creates a separator."},"id":"LibTmux::Client::MenuItem.label","kind":"property","modifiers":[],"name":"label","package":"LibTmux","parent":"LibTmux::Client::MenuItem","product":"core","publicId":"LibTmux::Client::MenuItem.label","signatures":[],"source":{"file":"lib/LibTmux/Client.rakumod","line":34,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-client-menuitem-label"},{"apiScope":"exported","doc":{"body":"# Interpretation boundaries\n\nInvocation encodes a tmux command, not a shell command or a FORMAT literal.\nDouble quoting alone does not suppress tmux tilde expansion. Exact octal\nescapes preserve quotes, backslashes, dollars, tildes, controls and high bytes.\nThe encoded size limit applies after expansion and before dispatch.\n\nEngine code inserts command separators deliberately between Invocation values;\nliteral semicolons inside their argument values remain data. Commands which\ninterpret FORMAT syntax require an additional command-specific policy.\n\n\n\n# Single-operation admission\n\nEffectful entry points use ` is single-operation ` to reject Junction arguments\nbefore Raku can autothread a typed method into several operations. Unknown named\narguments are rejected unless the method explicitly forwards a slurpy options\nhash; the receiving operation validates those forwarded names. Nested command\noperands remain the responsibility of Invocation and the command's validators.\nNative signatures, defaults and constraints retain their normal binding rules.\nAn effectful multi must guard its explicit proto, since candidate dispatch can\nautothread before a wrapper on an individual candidate runs.\nRole methods use capture admission in the proto body before typed candidate\ndispatch. Wrapping an unspecialized role method loses its private-method context\nafter precompilation on the pinned compiler.\n\n` is single-operation('async') ` returns one broken Promise for rejected input or\na synchronous exception from the method. Junctions and unknown names produce\n` X::LibTmux::Command ` with ` kind ` argument and ` outcome ` NotStarted. Native\nbinding errors and exceptions from the body retain their types. An accepted\nmethod's Promise passes through unchanged. Portable query validation keeps its\nown ` InvalidFilter ` policy, while local selections retain native Junction\nmatching.","summary":""},"id":"LibTmux::Command","kind":"module","modifiers":[],"name":"Command","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Command","signatures":[],"source":{"file":"lib/LibTmux/Command.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-command"},{"apiScope":"exported","doc":{"body":"One copied tmux command with distinct argv and command-language encodings.","summary":"One copied tmux command with distinct argv and command-language encodings."},"id":"LibTmux::Command::Invocation","kind":"class","modifiers":[],"name":"Invocation","package":"LibTmux","parent":"LibTmux::Command","product":"core","publicId":"LibTmux::Command::Invocation","signatures":[],"source":{"file":"lib/LibTmux/Command.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-command-invocation"},{"apiScope":"exported","doc":{"body":"Original literal values, detached from the caller's membership containers.","summary":"Original literal values, detached from the caller's membership containers."},"id":"LibTmux::Command::Invocation.argv","kind":"method","modifiers":[],"name":"argv","package":"LibTmux","parent":"LibTmux::Command::Invocation","product":"core","publicId":"LibTmux::Command::Invocation.argv","signatures":[{"params":[],"raw":"method argv(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"argv","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Command.rakumod","line":86,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-command-invocation-argv"},{"apiScope":"exported","doc":{"body":"Protect literal final semicolons from tmux's OS-argv command separator.","summary":"Protect literal final semicolons from tmux's OS-argv command separator."},"id":"LibTmux::Command::Invocation.as-argv","kind":"method","modifiers":[],"name":"as-argv","package":"LibTmux","parent":"LibTmux::Command::Invocation","product":"core","publicId":"LibTmux::Command::Invocation.as-argv","signatures":[{"params":[],"raw":"method as-argv(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"as-argv","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Command.rakumod","line":89,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-command-invocation-as-argv"},{"apiScope":"exported","doc":{"body":"A bounded tmux command string, with no shell expansion or Raku evaluation.","summary":"A bounded tmux command string, with no shell expansion or Raku evaluation."},"id":"LibTmux::Command::Invocation.source","kind":"method","modifiers":[],"name":"source","package":"LibTmux","parent":"LibTmux::Command::Invocation","product":"core","publicId":"LibTmux::Command::Invocation.source","signatures":[{"params":[],"raw":"method source(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"source","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Command.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-command-invocation-source"},{"apiScope":"exported","doc":{"body":"# Configuration and stored commands\n\nOptions, Environment, Buffers, Hooks and KeyBindings are value-only facades\nbound to an endpoint and daemon incarnation. Construction and schema access\nperform no I/O. Each operation owns and closes its temporary command runtime;\nit checks daemon identity and applies one timeout and output bound.\n\nOptions use source-qualified types and ranges from :obj:`LibTmux::Catalogue <LibTmux::Catalogue>`.\nFlags require Bool, numeric options reject Bool, and array writes require an\nexplicit index. ` entries ` preserves inherited provenance; ` get ` returns a\nnative scalar or an indexed Map. Unknown native options use the explicitly\nnamed raw operations. User options in the typed API use ` @ ` followed by\nletters, digits, underscores or hyphens. Native printed command values are\nsource text, not parsed Invocation values.\n\nEnvironment reads distinguish an absent entry, an explicit removed marker,\nand hidden entries. ` :hidden ` selects hidden entries only. Environment names\nuse the portable variable alphabet. ` get ` requests only that name; ` list `\nrefuses a native entry whose name falls outside the declared alphabet.\nValues preserve bytes through UTF8-C8;\nreading the shell-shaped output never executes it. Buffer content is acquired\nseparately as Blob and may contain NUL.\n\nHooks and key bindings accept :obj:`LibTmux::Command::Invocation <LibTmux::Command::Invocation>` for commands\nto store. Reads preserve tmux's printed command source without executing or\nreconstructing it. Legacy key listings mark notes Unloaded; modern projected\nlistings capture them. Key table names use letters, digits, underscores or\nhyphens so legacy native listings remain unambiguous.\n\nHook ` run ` acknowledges queuing. Paste and other mutations acknowledge tmux\ncommands; they do not prove that a pane application consumed input or that a\nhook's asynchronous work completed. Timeouts after dispatch cannot roll back\nserver effects. Captured values do not refresh themselves.","summary":""},"id":"LibTmux::Configuration","kind":"module","modifiers":[],"name":"Configuration","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Configuration","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration"},{"apiScope":"exported","doc":{"body":"Buffer metadata is separate from explicitly acquired binary contents.","summary":"Buffer metadata is separate from explicitly acquired binary contents."},"id":"LibTmux::Configuration::BufferInfo","kind":"class","modifiers":[],"name":"BufferInfo","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::BufferInfo","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":407,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-bufferinfo"},{"apiScope":"exported","doc":{"body":"Buffer creation time as Unix seconds.","summary":"Buffer creation time as Unix seconds."},"id":"LibTmux::Configuration::BufferInfo.created","kind":"property","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Configuration::BufferInfo","product":"core","publicId":"LibTmux::Configuration::BufferInfo.created","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":413,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-configuration-bufferinfo-created"},{"apiScope":"exported","doc":{"body":"Exact observed resource or option name.","summary":"Exact observed resource or option name."},"id":"LibTmux::Configuration::BufferInfo.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Configuration::BufferInfo","product":"core","publicId":"LibTmux::Configuration::BufferInfo.name","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":409,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-bufferinfo-name"},{"apiScope":"exported","doc":{"body":"Native buffer preview text; it is not the complete binary content.","summary":"Native buffer preview text; it is not the complete binary content."},"id":"LibTmux::Configuration::BufferInfo.sample","kind":"property","modifiers":[],"name":"sample","package":"LibTmux","parent":"LibTmux::Configuration::BufferInfo","product":"core","publicId":"LibTmux::Configuration::BufferInfo.sample","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":415,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-bufferinfo-sample"},{"apiScope":"exported","doc":{"body":"Buffer content length in bytes; content acquisition is separate.","summary":"Buffer content length in bytes; content acquisition is separate."},"id":"LibTmux::Configuration::BufferInfo.size","kind":"property","modifiers":[],"name":"size","package":"LibTmux","parent":"LibTmux::Configuration::BufferInfo","product":"core","publicId":"LibTmux::Configuration::BufferInfo.size","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":411,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-configuration-bufferinfo-size"},{"apiScope":"exported","doc":{"body":"Server-scoped paste buffers with binary load and save operations.","summary":"Server-scoped paste buffers with binary load and save operations."},"id":"LibTmux::Configuration::Buffers","kind":"class","modifiers":[],"name":"Buffers","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::Buffers","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":419,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers"},{"apiScope":"exported","doc":{"body":"Copy endpoint, scope and limits through constructor validation.","summary":"Copy endpoint, scope and limits through constructor validation."},"id":"LibTmux::Configuration::Buffers.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-clone"},{"apiScope":"exported","doc":{"body":"Delete the named buffer.","summary":"Delete the named buffer."},"id":"LibTmux::Configuration::Buffers.delete","kind":"method","modifiers":[],"name":"delete","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.delete","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method delete(Str:D $name --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"delete","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":448,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-delete"},{"apiScope":"exported","doc":{"body":"Acquire complete buffer bytes, including NUL, within the output bound.","summary":"Acquire complete buffer bytes, including NUL, within the output bound."},"id":"LibTmux::Configuration::Buffers.get","kind":"method","modifiers":[],"name":"get","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.get","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method get(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"get","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":437,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-get"},{"apiScope":"exported","doc":{"body":"Acquire buffer metadata without loading the complete contents.","summary":"Acquire buffer metadata without loading the complete contents."},"id":"LibTmux::Configuration::Buffers.list","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":424,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-list"},{"apiScope":"exported","doc":{"body":"Paste into an explicit pane, optionally deleting the buffer afterward.","summary":"Paste into an explicit pane, optionally deleting the buffer afterward."},"id":"LibTmux::Configuration::Buffers.paste","kind":"method","modifiers":[],"name":"paste","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.paste","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"False","keywordOnly":true,"name":"$delete","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$bracketed","optional":true,"type":"Bool"},{"keywordOnly":true,"name":"$separator","optional":true,"type":"Str"}],"raw":"method paste(Str:D $name, PaneId:D $pane, Bool :$delete = False,\n                 Bool :$bracketed = False, Str :$separator --> Result:D)","references":[{"end":34,"start":26,"target":"LibTmux::Types::PaneId"},{"end":136,"start":128,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"paste","declaration":true},{"text":"(Str:D $name, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" $pane, Bool :$delete = False,\n                 Bool :$bracketed = False, Str :$separator --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":458,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-paste"},{"apiScope":"exported","doc":{"body":"Load binary stdin into the named server buffer.","summary":"Load binary stdin into the named server buffer."},"id":"LibTmux::Configuration::Buffers.put","kind":"method","modifiers":[],"name":"put","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.put","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$bytes","optional":false,"type":"Blob:D"}],"raw":"method put(Str:D $name, Blob:D $bytes --> Result:D)","references":[{"end":50,"start":42,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"put","declaration":true},{"text":"(Str:D $name, Blob:D $bytes --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":443,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-put"},{"apiScope":"exported","doc":{"body":"Rename a buffer without decoding its contents.","summary":"Rename a buffer without decoding its contents."},"id":"LibTmux::Configuration::Buffers.rename","kind":"method","modifiers":[],"name":"rename","package":"LibTmux","parent":"LibTmux::Configuration::Buffers","product":"core","publicId":"LibTmux::Configuration::Buffers.rename","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$new-name","optional":false,"type":"Str:D"}],"raw":"method rename(Str:D $name, Str:D $new-name --> Result:D)","references":[{"end":55,"start":47,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"rename","declaration":true},{"text":"(Str:D $name, Str:D $new-name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":453,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-buffers-rename"},{"apiScope":"exported","doc":{"body":"Session or global environment, including hidden and removed entries.","summary":"Session or global environment, including hidden and removed entries."},"id":"LibTmux::Configuration::Environment","kind":"class","modifiers":[],"name":"Environment","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::Environment","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":351,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment"},{"apiScope":"exported","doc":{"body":"Copy endpoint, scope and limits through constructor validation.","summary":"Copy endpoint, scope and limits through constructor validation."},"id":"LibTmux::Configuration::Environment.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-clone"},{"apiScope":"exported","doc":{"body":"Find a captured entry; Nil means absent from the requested visibility class.","summary":"Find a captured entry; Nil means absent from the requested visibility class."},"id":"LibTmux::Configuration::Environment.get","kind":"method","modifiers":[],"name":"get","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.get","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$hidden","optional":true,"type":"Bool"}],"raw":"method get(Str:D $name, Bool :$hidden = False)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"get","declaration":true},{"text":"(Str:D $name, Bool :$hidden = False)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":366,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-get"},{"apiScope":"exported","doc":{"body":"Capture normal entries, or only hidden entries when requested explicitly.","summary":"Capture normal entries, or only hidden entries when requested explicitly."},"id":"LibTmux::Configuration::Environment.list","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.list","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$hidden","optional":true,"type":"Bool"}],"raw":"method list(Bool :$hidden = False --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(Bool :$hidden = False --> List:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":358,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-list"},{"apiScope":"exported","doc":{"body":"Store a removed marker so the variable is omitted from newly spawned processes.","summary":"Store a removed marker so the variable is omitted from newly spawned processes."},"id":"LibTmux::Configuration::Environment.remove","kind":"method","modifiers":[],"name":"remove","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.remove","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method remove(Str:D $name --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"remove","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":400,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-remove"},{"apiScope":"exported","doc":{"body":"Store literal text without FORMAT or shell expansion; NUL is not representable.","summary":"Store literal text without FORMAT or shell expansion; NUL is not representable."},"id":"LibTmux::Configuration::Environment.set","kind":"method","modifiers":[],"name":"set","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.set","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$value","optional":false,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$hidden","optional":true,"type":"Bool"}],"raw":"method set(Str:D $name, Str:D $value, Bool :$hidden = False --> Result:D)","references":[{"end":72,"start":64,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set","declaration":true},{"text":"(Str:D $name, Str:D $value, Bool :$hidden = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":387,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-set"},{"apiScope":"exported","doc":{"body":"Delete an entry from this environment.","summary":"Delete an entry from this environment."},"id":"LibTmux::Configuration::Environment.unset","kind":"method","modifiers":[],"name":"unset","package":"LibTmux","parent":"LibTmux::Configuration::Environment","product":"core","publicId":"LibTmux::Configuration::Environment.unset","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method unset(Str:D $name --> Result:D)","references":[{"end":37,"start":29,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unset","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":395,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environment-unset"},{"apiScope":"exported","doc":{"body":"Environment absence and an explicit removed marker are different states.","summary":"Environment absence and an explicit removed marker are different states."},"id":"LibTmux::Configuration::EnvironmentValue","kind":"class","modifiers":[],"name":"EnvironmentValue","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":266,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environmentvalue"},{"apiScope":"exported","doc":{"body":"Captured environment bytes, preserved separately from text conversion.","summary":"Captured environment bytes, preserved separately from text conversion."},"id":"LibTmux::Configuration::EnvironmentValue.bytes","kind":"property","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.bytes","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":270,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-configuration-environmentvalue-bytes"},{"apiScope":"exported","doc":{"body":"Revalidate copies and detach mutable byte input.","summary":"Revalidate copies and detach mutable byte input."},"id":"LibTmux::Configuration::EnvironmentValue.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":279,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environmentvalue-clone"},{"apiScope":"exported","doc":{"body":"Whether this entry belongs to the explicitly requested hidden environment.","summary":"Whether this entry belongs to the explicitly requested hidden environment."},"id":"LibTmux::Configuration::EnvironmentValue.hidden","kind":"property","modifiers":[],"name":"hidden","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.hidden","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":274,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-configuration-environmentvalue-hidden"},{"apiScope":"exported","doc":{"body":"Exact observed resource or option name.","summary":"Exact observed resource or option name."},"id":"LibTmux::Configuration::EnvironmentValue.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.name","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":268,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-environmentvalue-name"},{"apiScope":"exported","doc":{"body":"Whether tmux marks this variable for removal from child environments.","summary":"Whether tmux marks this variable for removal from child environments."},"id":"LibTmux::Configuration::EnvironmentValue.removed","kind":"property","modifiers":[],"name":"removed","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.removed","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":272,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-configuration-environmentvalue-removed"},{"apiScope":"exported","doc":{"body":"Decode captured bytes losslessly, or return Nil for an explicit removed marker.","summary":"Decode captured bytes losslessly, or return Nil for an explicit removed marker."},"id":"LibTmux::Configuration::EnvironmentValue.value","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Configuration::EnvironmentValue","product":"core","publicId":"LibTmux::Configuration::EnvironmentValue.value","signatures":[{"params":[],"raw":"method value()","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":277,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-environmentvalue-value"},{"apiScope":"exported","doc":{"body":"Named hook command arrays. Reading a hook never executes its command source.","summary":"Named hook command arrays. Reading a hook never executes its command source."},"id":"LibTmux::Configuration::Hooks","kind":"class","modifiers":[],"name":"Hooks","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::Hooks","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":470,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks"},{"apiScope":"exported","doc":{"body":"Append one command to the hook array using tmux's native array allocation.","summary":"Append one command to the hook array using tmux's native array allocation."},"id":"LibTmux::Configuration::Hooks.append","kind":"method","modifiers":[],"name":"append","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.append","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"}],"raw":"method append(Str:D $name, Invocation:D $command --> Result:D)","references":[{"end":39,"start":27,"target":"LibTmux::Command::Invocation"},{"end":61,"start":53,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"append","declaration":true},{"text":"(Str:D $name, "},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":499,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-append"},{"apiScope":"exported","doc":{"body":"Copy endpoint, scope and limits through constructor validation.","summary":"Copy endpoint, scope and limits through constructor validation."},"id":"LibTmux::Configuration::Hooks.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-clone"},{"apiScope":"exported","doc":{"body":"Read local hook entries; each value is native printed command source.","summary":"Read local hook entries; each value is native printed command source."},"id":"LibTmux::Configuration::Hooks.list","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.list","signatures":[{"params":[{"keywordOnly":true,"name":"$name","optional":true,"type":"Str"}],"raw":"method list(Str :$name --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(Str :$name --> List:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":483,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-list"},{"apiScope":"exported","doc":{"body":"Queue a hook now. Acknowledgement does not prove its commands' effects.","summary":"Queue a hook now. Acknowledgement does not prove its commands' effects."},"id":"LibTmux::Configuration::Hooks.run","kind":"method","modifiers":[],"name":"run","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.run","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method run(Str:D $name --> Result:D)","references":[{"end":35,"start":27,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":510,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-run"},{"apiScope":"exported","doc":{"body":"Set one hook index to a validated tmux command; the command is deferred.","summary":"Set one hook index to a validated tmux command; the command is deferred."},"id":"LibTmux::Configuration::Hooks.set","kind":"method","modifiers":[],"name":"set","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.set","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"0","keywordOnly":true,"name":"$index","optional":true,"type":"Count:D"}],"raw":"method set(Str:D $name, Invocation:D $command, Count:D :$index = 0 --> Result:D)","references":[{"end":36,"start":24,"target":"LibTmux::Command::Invocation"},{"end":54,"start":47,"target":"LibTmux::Types::Count"},{"end":79,"start":71,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set","declaration":true},{"text":"(Str:D $name, "},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":" :$index = 0 --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":494,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-set"},{"apiScope":"exported","doc":{"body":"Remove a hook array or one explicit index.","summary":"Remove a hook array or one explicit index."},"id":"LibTmux::Configuration::Hooks.unset","kind":"method","modifiers":[],"name":"unset","package":"LibTmux","parent":"LibTmux::Configuration::Hooks","product":"core","publicId":"LibTmux::Configuration::Hooks.unset","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"default":"Count","keywordOnly":true,"name":"$index","optional":true,"type":"Count"}],"raw":"method unset(Str:D $name, Count :$index = Count --> Result:D)","references":[{"end":31,"start":26,"target":"LibTmux::Types::Count"},{"end":47,"start":42,"target":"LibTmux::Types::Count"},{"end":60,"start":52,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unset","declaration":true},{"text":"(Str:D $name, "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$index = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":504,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-hooks-unset"},{"apiScope":"exported","doc":{"body":"Captured binding metadata. Legacy listings leave note-state Unloaded.","summary":"Captured binding metadata. Legacy listings leave note-state Unloaded."},"id":"LibTmux::Configuration::KeyBinding","kind":"class","modifiers":[],"name":"KeyBinding","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::KeyBinding","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":517,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybinding"},{"apiScope":"exported","doc":{"body":"Observed tmux command syntax; retaining it does not execute it.","summary":"Observed tmux command syntax; retaining it does not execute it."},"id":"LibTmux::Configuration::KeyBinding.command-source","kind":"property","modifiers":[],"name":"command-source","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.command-source","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":525,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-keybinding-command-source"},{"apiScope":"exported","doc":{"body":"Native tmux key spelling.","summary":"Native tmux key spelling."},"id":"LibTmux::Configuration::KeyBinding.key","kind":"property","modifiers":[],"name":"key","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.key","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":521,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-keybinding-key"},{"apiScope":"exported","doc":{"body":"Binding note text when the selected profile can acquire it.","summary":"Binding note text when the selected profile can acquire it."},"id":"LibTmux::Configuration::KeyBinding.note","kind":"property","modifiers":[],"name":"note","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.note","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":527,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-keybinding-note"},{"apiScope":"exported","doc":{"body":"Availability of the note; older profiles retain Unloaded rather than inventing text.","summary":"Availability of the note; older profiles retain Unloaded rather than inventing text."},"id":"LibTmux::Configuration::KeyBinding.note-state","kind":"property","modifiers":[],"name":"note-state","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.note-state","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":529,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"ValueState:D","slug":"libtmux-configuration-keybinding-note-state"},{"apiScope":"exported","doc":{"body":"Whether tmux allows this binding to repeat.","summary":"Whether tmux allows this binding to repeat."},"id":"LibTmux::Configuration::KeyBinding.repeat","kind":"property","modifiers":[],"name":"repeat","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.repeat","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":523,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-configuration-keybinding-repeat"},{"apiScope":"exported","doc":{"body":"Key-table name in which the binding was observed.","summary":"Key-table name in which the binding was observed."},"id":"LibTmux::Configuration::KeyBinding.table","kind":"property","modifiers":[],"name":"table","package":"LibTmux","parent":"LibTmux::Configuration::KeyBinding","product":"core","publicId":"LibTmux::Configuration::KeyBinding.table","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":519,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-keybinding-table"},{"apiScope":"exported","doc":{"body":"Server key tables. Invocation keeps stored command arguments distinct.","summary":"Server key tables. Invocation keeps stored command arguments distinct."},"id":"LibTmux::Configuration::KeyBindings","kind":"class","modifiers":[],"name":"KeyBindings","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::KeyBindings","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":539,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings"},{"apiScope":"exported","doc":{"body":"Bind a key to one command, with optional repeatability and literal note.","summary":"Bind a key to one command, with optional repeatability and literal note."},"id":"LibTmux::Configuration::KeyBindings.bind","kind":"method","modifiers":[],"name":"bind","package":"LibTmux","parent":"LibTmux::Configuration::KeyBindings","product":"core","publicId":"LibTmux::Configuration::KeyBindings.bind","signatures":[{"params":[{"keywordOnly":false,"name":"$key","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"'prefix'","keywordOnly":true,"name":"$table","optional":true,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$repeat","optional":true,"type":"Bool"},{"keywordOnly":true,"name":"$note","optional":true,"type":"Str"}],"raw":"method bind(Str:D $key, Invocation:D $command, Str:D :$table = 'prefix',\n                Bool :$repeat = False, Str :$note --> Result:D)","references":[{"end":36,"start":24,"target":"LibTmux::Command::Invocation"},{"end":135,"start":127,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bind","declaration":true},{"text":"(Str:D $key, "},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, Str:D :$table = 'prefix',\n                Bool :$repeat = False, Str :$note --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":544,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings-bind"},{"apiScope":"exported","doc":{"body":"Remove the explicitly named table and all its bindings.","summary":"Remove the explicitly named table and all its bindings."},"id":"LibTmux::Configuration::KeyBindings.clear","kind":"method","modifiers":[],"name":"clear","package":"LibTmux","parent":"LibTmux::Configuration::KeyBindings","product":"core","publicId":"LibTmux::Configuration::KeyBindings.clear","signatures":[{"params":[{"keywordOnly":false,"name":"$table","optional":false,"type":"Str:D"}],"raw":"method clear(Str:D $table --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clear","declaration":true},{"text":"(Str:D $table --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":559,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings-clear"},{"apiScope":"exported","doc":{"body":"Copy endpoint, scope and limits through constructor validation.","summary":"Copy endpoint, scope and limits through constructor validation."},"id":"LibTmux::Configuration::KeyBindings.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::KeyBindings","product":"core","publicId":"LibTmux::Configuration::KeyBindings.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings-clone"},{"apiScope":"exported","doc":{"body":"Capture one table; modern profiles include notes, legacy profiles mark them unloaded.","summary":"Capture one table; modern profiles include notes, legacy profiles mark them unloaded."},"id":"LibTmux::Configuration::KeyBindings.list","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Configuration::KeyBindings","product":"core","publicId":"LibTmux::Configuration::KeyBindings.list","signatures":[{"params":[{"default":"'prefix'","keywordOnly":true,"name":"$table","optional":true,"type":"Str:D"}],"raw":"method list(Str:D :$table = 'prefix' --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(Str:D :$table = 'prefix' --> List:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":564,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings-list"},{"apiScope":"exported","doc":{"body":"Remove one binding. Unknown tables remain operational errors.","summary":"Remove one binding. Unknown tables remain operational errors."},"id":"LibTmux::Configuration::KeyBindings.unbind","kind":"method","modifiers":[],"name":"unbind","package":"LibTmux","parent":"LibTmux::Configuration::KeyBindings","product":"core","publicId":"LibTmux::Configuration::KeyBindings.unbind","signatures":[{"params":[{"keywordOnly":false,"name":"$key","optional":false,"type":"Str:D"},{"default":"'prefix'","keywordOnly":true,"name":"$table","optional":true,"type":"Str:D"}],"raw":"method unbind(Str:D $key, Str:D :$table = 'prefix' --> Result:D)","references":[{"end":63,"start":55,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unbind","declaration":true},{"text":"(Str:D $key, Str:D :$table = 'prefix' --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":554,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-keybindings-unbind"},{"apiScope":"exported","doc":{"body":"One observed option value. The source schema determines its native scalar type.","summary":"One observed option value. The source schema determines its native scalar type."},"id":"LibTmux::Configuration::OptionValue","kind":"class","modifiers":[],"name":"OptionValue","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::OptionValue","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":109,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-optionvalue"},{"apiScope":"exported","doc":{"body":"Array member index; undefined for a scalar option.","summary":"Array member index; undefined for a scalar option."},"id":"LibTmux::Configuration::OptionValue.index","kind":"property","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Configuration::OptionValue","product":"core","publicId":"LibTmux::Configuration::OptionValue.index","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":113,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-configuration-optionvalue-index"},{"apiScope":"exported","doc":{"body":"Whether the effective value came from an ancestor option scope.","summary":"Whether the effective value came from an ancestor option scope."},"id":"LibTmux::Configuration::OptionValue.inherited","kind":"property","modifiers":[],"name":"inherited","package":"LibTmux","parent":"LibTmux::Configuration::OptionValue","product":"core","publicId":"LibTmux::Configuration::OptionValue.inherited","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":115,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-configuration-optionvalue-inherited"},{"apiScope":"exported","doc":{"body":"Exact observed resource or option name.","summary":"Exact observed resource or option name."},"id":"LibTmux::Configuration::OptionValue.name","kind":"property","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Configuration::OptionValue","product":"core","publicId":"LibTmux::Configuration::OptionValue.name","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":111,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-configuration-optionvalue-name"},{"apiScope":"exported","doc":{"body":"Decoded native option value; its type follows the option catalogue.","summary":"Decoded native option value; its type follows the option catalogue."},"id":"LibTmux::Configuration::OptionValue.value","kind":"property","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Configuration::OptionValue","product":"core","publicId":"LibTmux::Configuration::OptionValue.value","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":117,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Mu","slug":"libtmux-configuration-optionvalue-value"},{"apiScope":"exported","doc":{"body":"Typed native options. Reads and writes are explicit daemon operations.","summary":"Typed native options. Reads and writes are explicit daemon operations."},"id":"LibTmux::Configuration::Options","kind":"class","modifiers":[],"name":"Options","package":"LibTmux","parent":"LibTmux::Configuration","product":"core","publicId":"LibTmux::Configuration::Options","signatures":[],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":164,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options"},{"apiScope":"exported","doc":{"body":"Copy endpoint, scope and limits through constructor validation.","summary":"Copy endpoint, scope and limits through constructor validation."},"id":"LibTmux::Configuration::Options.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-clone"},{"apiScope":"exported","doc":{"body":"Inspect the source-qualified schema locally; user options have text values.","summary":"Inspect the source-qualified schema locally; user options have text values."},"id":"LibTmux::Configuration::Options.describe","kind":"method","modifiers":[],"name":"describe","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.describe","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method describe(Str:D $name --> LibTmux::Catalogue::OptionSpec:D)","references":[{"end":64,"start":32,"target":"LibTmux::Catalogue::OptionSpec"}],"returns":"LibTmux::Catalogue::OptionSpec:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"describe","declaration":true},{"text":"(Str:D $name --> "},{"text":"LibTmux::Catalogue::OptionSpec:D","target":"LibTmux::Catalogue::OptionSpec"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":166,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-describe"},{"apiScope":"exported","doc":{"body":"Read values, array indices and inherited provenance as captured entries.","summary":"Read values, array indices and inherited provenance as captured entries."},"id":"LibTmux::Configuration::Options.entries","kind":"method","modifiers":[],"name":"entries","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.entries","signatures":[{"params":[{"keywordOnly":true,"name":"$name","optional":true,"type":"Str"},{"default":"True","keywordOnly":true,"name":"$effective","optional":true,"type":"Bool"}],"raw":"method entries(Str :$name, Bool :$effective = True --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entries","declaration":true},{"text":"(Str :$name, Bool :$effective = True --> List:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":183,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-entries"},{"apiScope":"exported","doc":{"body":"Read a native scalar, an array Map, or Nil for an absent local value/member.","summary":"Read a native scalar, an array Map, or Nil for an absent local value/member."},"id":"LibTmux::Configuration::Options.get","kind":"method","modifiers":[],"name":"get","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.get","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$index","optional":true,"type":"Int"},{"default":"True","keywordOnly":true,"name":"$effective","optional":true,"type":"Bool"}],"raw":"method get(Str:D $name, Int :$index, Bool :$effective = True)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"get","declaration":true},{"text":"(Str:D $name, Int :$index, Bool :$effective = True)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":202,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-get"},{"apiScope":"exported","doc":{"body":"Read raw native output for an option outside the declared typed schema.","summary":"Read raw native output for an option outside the declared typed schema."},"id":"LibTmux::Configuration::Options.get-raw","kind":"method","modifiers":[],"name":"get-raw","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.get-raw","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method get-raw(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"get-raw","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":259,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-get-raw"},{"apiScope":"exported","doc":{"body":"Validate a typed value and set one scalar or explicitly indexed array member.","summary":"Validate a typed value and set one scalar or explicitly indexed array member."},"id":"LibTmux::Configuration::Options.set","kind":"method","modifiers":[],"name":"set","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.set","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$value","optional":false},{"keywordOnly":true,"name":"$index","optional":true,"type":"Int"}],"raw":"method set(Str:D $name, $value, Int :$index --> Result:D)","references":[{"end":56,"start":48,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set","declaration":true},{"text":"(Str:D $name, $value, Int :$index --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":215,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-set"},{"apiScope":"exported","doc":{"body":"Explicit schema escape hatch. tmux validates the option and interprets its value.","summary":"Explicit schema escape hatch. tmux validates the option and interprets its value."},"id":"LibTmux::Configuration::Options.set-raw","kind":"method","modifiers":[],"name":"set-raw","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.set-raw","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"$value","optional":false,"type":"Str:D"}],"raw":"method set-raw(Str:D $name, Str:D $value --> Result:D)","references":[{"end":53,"start":45,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set-raw","declaration":true},{"text":"(Str:D $name, Str:D $value --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":254,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-set-raw"},{"apiScope":"exported","doc":{"body":"Remove a local value or array member; tmux's inherited/default value may remain.","summary":"Remove a local value or array member; tmux's inherited/default value may remain."},"id":"LibTmux::Configuration::Options.unset","kind":"method","modifiers":[],"name":"unset","package":"LibTmux","parent":"LibTmux::Configuration::Options","product":"core","publicId":"LibTmux::Configuration::Options.unset","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$index","optional":true,"type":"Int"}],"raw":"method unset(Str:D $name, Int :$index --> Result:D)","references":[{"end":50,"start":42,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unset","declaration":true},{"text":"(Str:D $name, Int :$index --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Configuration.rakumod","line":246,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-configuration-options-unset"},{"apiScope":"exported","doc":{"body":"# Control framing and delivery\n\nDecoder frames bytes on LF and correlates all three numeric guard fields.\nNotification-shaped lines within a response remain payload. PaneOutput keeps\noctal-decoded bytes, including NUL and incomplete UTF-8; text decoding belongs\nto a separate incremental consumer. UnknownEvent preserves future notifications.\n\nThe tmux wire protocol does not escape arbitrary command payloads from matching\ntheir own terminal guard. Managed reads must use declared, prefixed projections;\nraw command output cannot promise lossless framing for guard-shaped payloads.\nA Response acknowledges dispatch. Its end guard does not establish completion\nof a launched job, popup, detach, or other asynchronous effect.\nSome queued jobs print outside response blocks. UnframedOutput preserves such\nlines, but the protocol cannot distinguish arbitrary job text from notifications.\n\nEvent delivery is live, without replay. A late tap misses earlier events.\nEach subscriber has an independently bounded queue and serial worker. A slow\nsubscriber overflows explicitly; a throwing callback terminates only its own\nsubscription. Closing a tap discards queued values. Owner completion drains\nalready accepted values before done; failure drains before quit. User callbacks\nalready executing cannot be cancelled, and owner teardown does not wait for them.","summary":""},"id":"LibTmux::Control","kind":"module","modifiers":[],"name":"Control","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Control","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control"},{"apiScope":"exported","doc":{"body":"# Owned control connection\n\nConnection connects to an exact session on an observed daemon. Startup verifies\nthe daemon again over the persistent connection. The ignore-size client flag\navoids changing pane dimensions. New layouts are negotiated when supported;\nolder profiles retain their native control layout representation.\n\nCommands are serialized through one bounded queue. A separate unpredictable\nFORMAT barrier correlates every response, including nested commands and jobs\nwhich print after their end guard. A barrier means the tmux command queue reached\nthat point; background jobs and external effects still need domain-specific\ncompletion evidence. Raw command output has the framing limitations described\nby :obj:`LibTmux::Control <LibTmux::Control>`. Declared projections avoid arbitrary output delimiters.\n\nEach request owns a deadline from admission. Cancelling an unsent request leaves\nthe connection usable. Timeout or cancellation after dispatch closes the whole\nconnection because later response ownership is uncertain. Effects already sent\nremain indeterminate. Closing stops the client, not the daemon or launched jobs.\n\nAn event Supply is shared, live and bounded per subscriber. Reconnect requires a\nnew Connection and explicit snapshot acquisition; old requests and observations\nnever migrate automatically. Every connection has a distinct epoch.","summary":""},"id":"LibTmux::Control::Connection","kind":"class","modifiers":[],"name":"Connection","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::Connection","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":5,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection"},{"apiScope":"exported","doc":{"body":"Separate termination and reaping budget in milliseconds.","summary":"Separate termination and reaping budget in milliseconds."},"id":"LibTmux::Control::Connection.cleanup-timeout-ms","kind":"property","modifiers":[],"name":"cleanup-timeout-ms","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.cleanup-timeout-ms","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":95,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-connection-cleanup-timeout-ms"},{"apiScope":"exported","doc":{"body":"Refuse cloning of a process and its pending request state.","summary":"Refuse cloning of a process and its pending request state."},"id":"LibTmux::Control::Connection.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":145,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-clone"},{"apiScope":"exported","doc":{"body":"Stop admission, settle every request and reap only this connection's client.","summary":"Stop admission, settle every request and reap only this connection's client."},"id":"LibTmux::Control::Connection.close","kind":"method","modifiers":[],"name":"close","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.close","signatures":[{"params":[],"raw":"method close(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":554,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-close"},{"apiScope":"exported","doc":{"body":"Share one bounded shutdown which settles pending work and reaps only this client.","summary":"Share one bounded shutdown which settles pending work and reaps only this client."},"id":"LibTmux::Control::Connection.close-async","kind":"method","modifiers":[],"name":"close-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.close-async","signatures":[{"params":[],"raw":"method close-async(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close-async","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":556,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-close-async"},{"apiScope":"exported","doc":{"body":"Shared completion Promise for connection shutdown; callers cannot resolve it.","summary":"Shared completion Promise for connection shutdown; callers cannot resolve it."},"id":"LibTmux::Control::Connection.closed","kind":"method","modifiers":[],"name":"closed","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.closed","signatures":[{"params":[],"raw":"method closed(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"closed","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":151,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-closed"},{"apiScope":"exported","doc":{"body":"Observe, attach and verify a persistent connection to an exact session ID.","summary":"Observe, attach and verify a persistent connection to an exact session ID."},"id":"LibTmux::Control::Connection.connect","kind":"method","modifiers":[],"name":"connect","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.connect","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method connect(*%options --> LibTmux::Control::Connection:D)","references":[{"end":59,"start":29,"target":"LibTmux::Control::Connection"}],"returns":"LibTmux::Control::Connection:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"connect","declaration":true},{"text":"(*%options --> "},{"text":"LibTmux::Control::Connection:D","target":"LibTmux::Control::Connection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":160,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-connect"},{"apiScope":"exported","doc":{"body":"Resolve to a verified connection or reject after bounded startup cleanup.","summary":"Resolve to a verified connection or reject after bounded startup cleanup."},"id":"LibTmux::Control::Connection.connect-async","kind":"method","modifiers":[],"name":"connect-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.connect-async","signatures":[{"params":[{"keywordOnly":true,"name":"$endpoint","optional":false},{"keywordOnly":true,"name":"$session-id","optional":false},{"default":"Incarnation","keywordOnly":true,"name":"$incarnation","optional":true},{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true},{"default":"1_000","keywordOnly":true,"name":"$cleanup-timeout-ms","optional":true},{"default":"128","keywordOnly":true,"name":"$max-pending","optional":true},{"default":"8 * 1024 * 1024","keywordOnly":true,"name":"$max-output-bytes","optional":true},{"default":"12 * 1024","keywordOnly":true,"name":"$max-command-bytes","optional":true},{"default":"256","keywordOnly":true,"name":"$max-events","optional":true},{"default":"1024 * 1024","keywordOnly":true,"name":"$max-event-bytes","optional":true},{"default":"'auto'","keywordOnly":true,"name":"$new-layouts","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true}],"raw":"method connect-async(:$endpoint!, :$session-id!, :$incarnation = Incarnation,\n    :$timeout-ms = 10_000, :$cleanup-timeout-ms = 1_000, :$max-pending = 128,\n    :$max-output-bytes = 8 * 1024 * 1024, :$max-command-bytes = 12 * 1024,\n    :$max-events = 256, :$max-event-bytes = 1024 * 1024,\n    :$new-layouts = 'auto', :$cancel = Cancellation --> Promise:D)","references":[{"end":76,"start":65,"target":"LibTmux::Engine::Incarnation"},{"end":339,"start":327,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"connect-async","declaration":true},{"text":"(:$endpoint!, :$session-id!, :$incarnation = "},{"text":"Incarnation","target":"LibTmux::Engine::Incarnation"},{"text":",\n    :$timeout-ms = 10_000, :$cleanup-timeout-ms = 1_000, :$max-pending = 128,\n    :$max-output-bytes = 8 * 1024 * 1024, :$max-command-bytes = 12 * 1024,\n    :$max-events = 256, :$max-event-bytes = 1024 * 1024,\n    :$new-layouts = 'auto', :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":162,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-connect-async"},{"apiScope":"exported","doc":{"body":"Captured connection settings; retaining them owns no process.","summary":"Captured connection settings; retaining them owns no process."},"id":"LibTmux::Control::Connection.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-control-connection-endpoint"},{"apiScope":"exported","doc":{"body":"Unique connection identity; reconnecting always creates a new epoch.","summary":"Unique connection identity; reconnecting always creates a new epoch."},"id":"LibTmux::Control::Connection.epoch","kind":"property","modifiers":[],"name":"epoch","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.epoch","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":103,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-control-connection-epoch"},{"apiScope":"exported","doc":{"body":"All taps share this process; each receives independently bounded live delivery.","summary":"All taps share this process; each receives independently bounded live delivery."},"id":"LibTmux::Control::Connection.events","kind":"method","modifiers":[],"name":"events","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.events","signatures":[{"params":[],"raw":"method events(--> Supply:D)","references":[],"returns":"Supply:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"events","declaration":true},{"text":"(--> Supply:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":147,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-events"},{"apiScope":"exported","doc":{"body":"Execute one raw command, waiting for a separate queue barrier; no rollback is implied.","summary":"Execute one raw command, waiting for a separate queue barrier; no rollback is implied."},"id":"LibTmux::Control::Connection.execute","kind":"method","modifiers":[],"name":"execute","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.execute","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method execute($command, *%options --> Acknowledgement:D)","references":[{"end":56,"start":39,"target":"LibTmux::Control::Connection::Acknowledgement"}],"returns":"Acknowledgement:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"execute","declaration":true},{"text":"($command, *%options --> "},{"text":"Acknowledgement:D","target":"LibTmux::Control::Connection::Acknowledgement"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":404,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-execute"},{"apiScope":"exported","doc":{"body":"Queue one command and resolve its ordered acknowledgement; cancellation may close the connection.","summary":"Queue one command and resolve its ordered acknowledgement; cancellation may close the connection."},"id":"LibTmux::Control::Connection.execute-async","kind":"method","modifiers":[],"name":"execute-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.execute-async","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false},{"default":"Incarnation","keywordOnly":true,"name":"$incarnation","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true},{"default":"True","keywordOnly":true,"name":"$check","optional":true},{"default":"Instant","keywordOnly":true,"name":"$deadline","optional":true}],"raw":"method execute-async($command, :$incarnation = Incarnation, :$cancel = Cancellation,\n    :$check = True, :$deadline = Instant --> Promise:D)","references":[{"end":58,"start":47,"target":"LibTmux::Engine::Incarnation"},{"end":83,"start":71,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"execute-async","declaration":true},{"text":"($command, :$incarnation = "},{"text":"Incarnation","target":"LibTmux::Engine::Incarnation"},{"text":", :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":",\n    :$check = True, :$deadline = Instant --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":421,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-execute-async"},{"apiScope":"exported","doc":{"body":"Explain a query against this connection's immutable negotiated capabilities, without I/O.","summary":"Explain a query against this connection's immutable negotiated capabilities, without I/O."},"id":"LibTmux::Control::Connection.explain","kind":"method","modifiers":[],"name":"explain","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.explain","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"default":"Map.new","keywordOnly":true,"name":"$where","optional":true,"type":"Mu"},{"default":"'auto'","keywordOnly":true,"name":"$pushdown","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method explain(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto', *%unknown --> Plan:D)","references":[{"end":93,"start":87,"target":"LibTmux::Query::Plan::Plan"}],"returns":"Plan:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"explain","declaration":true},{"text":"(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto', *%unknown --> "},{"text":"Plan:D","target":"LibTmux::Query::Plan::Plan"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":485,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-explain"},{"apiScope":"exported","doc":{"body":"Explain pane restrictions and local residual work.","summary":"Explain pane restrictions and local residual work."},"id":"LibTmux::Control::Connection.explain-panes","kind":"method","modifiers":[],"name":"explain-panes","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.explain-panes","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method explain-panes(*%options --> Plan:D)","references":[{"end":41,"start":35,"target":"LibTmux::Query::Plan::Plan"}],"returns":"Plan:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"explain-panes","declaration":true},{"text":"(*%options --> "},{"text":"Plan:D","target":"LibTmux::Query::Plan::Plan"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":513,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-explain-panes"},{"apiScope":"exported","doc":{"body":"Terminal connection error, or an undefined Exception after normal close.","summary":"Terminal connection error, or an undefined Exception after normal close."},"id":"LibTmux::Control::Connection.failure","kind":"method","modifiers":[],"name":"failure","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.failure","signatures":[{"params":[],"raw":"method failure(--> Exception)","references":[],"returns":"Exception","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"failure","declaration":true},{"text":"(--> Exception)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-failure"},{"apiScope":"exported","doc":{"body":"Maximum encoded command size in bytes, including tmux quoting.","summary":"Maximum encoded command size in bytes, including tmux quoting."},"id":"LibTmux::Control::Connection.max-command-bytes","kind":"property","modifiers":[],"name":"max-command-bytes","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.max-command-bytes","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":101,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-connection-max-command-bytes"},{"apiScope":"exported","doc":{"body":"Per-response output-byte limit; retained stderr has the same separate bound.","summary":"Per-response output-byte limit; retained stderr has the same separate bound."},"id":"LibTmux::Control::Connection.max-output-bytes","kind":"property","modifiers":[],"name":"max-output-bytes","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.max-output-bytes","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":99,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-connection-max-output-bytes"},{"apiScope":"exported","doc":{"body":"Maximum admitted requests, including the active request and queued cancellations.","summary":"Maximum admitted requests, including the active request and queued cancellations."},"id":"LibTmux::Control::Connection.max-pending","kind":"property","modifiers":[],"name":"max-pending","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.max-pending","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":97,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-connection-max-pending"},{"apiScope":"exported","doc":{"body":"Refuse unstarted owners; construct a live owner through connect.","summary":"Refuse unstarted owners; construct a live owner through connect."},"id":"LibTmux::Control::Connection.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":143,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-new"},{"apiScope":"exported","doc":{"body":"Return the immutable identity and negotiated capabilities established at connection time.","summary":"Return the immutable identity and negotiated capabilities established at connection time."},"id":"LibTmux::Control::Connection.observation","kind":"method","modifiers":[],"name":"observation","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.observation","signatures":[{"params":[],"raw":"method observation(--> Observation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Observation"}],"returns":"Observation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"observation","declaration":true},{"text":"(--> "},{"text":"Observation:D","target":"LibTmux::Engine::Observation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":149,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-observation"},{"apiScope":"exported","doc":{"body":"Verify the connected daemon through a queue barrier without acquiring a graph.","summary":"Verify the connected daemon through a queue barrier without acquiring a graph."},"id":"LibTmux::Control::Connection.observe","kind":"method","modifiers":[],"name":"observe","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.observe","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method observe(*%options --> Observation:D)","references":[{"end":42,"start":29,"target":"LibTmux::Engine::Observation"}],"returns":"Observation:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"observe","declaration":true},{"text":"(*%options --> "},{"text":"Observation:D","target":"LibTmux::Engine::Observation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":463,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-observe"},{"apiScope":"exported","doc":{"body":"Verify daemon identity through a queued barrier and resolve the captured observation.","summary":"Verify daemon identity through a queued barrier and resolve the captured observation."},"id":"LibTmux::Control::Connection.observe-async","kind":"method","modifiers":[],"name":"observe-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.observe-async","signatures":[{"params":[{"default":"Instant","keywordOnly":true,"name":"$deadline","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true}],"raw":"method observe-async(:$deadline = Instant, :$cancel = Cancellation --> Promise:D)","references":[{"end":66,"start":54,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"observe-async","declaration":true},{"text":"(:$deadline = Instant, :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":465,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-observe-async"},{"apiScope":"exported","doc":{"body":"Owned control-client PID, or undefined before successful process creation.","summary":"Owned control-client PID, or undefined before successful process creation."},"id":"LibTmux::Control::Connection.pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.pid","signatures":[{"params":[],"raw":"method pid(--> Int)","references":[],"returns":"Int","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pid","declaration":true},{"text":"(--> Int)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":157,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-pid"},{"apiScope":"exported","doc":{"body":"Acquire a selection through this connection; retained observations keep no live owner.","summary":"Acquire a selection through this connection; retained observations keep no live owner."},"id":"LibTmux::Control::Connection.query","kind":"method","modifiers":[],"name":"query","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.query","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query(Mu $entity, *%options --> Positional:D)","references":[],"returns":"Positional:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query","declaration":true},{"text":"(Mu $entity, *%options --> Positional:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":491,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-query"},{"apiScope":"exported","doc":{"body":"Copy and validate query data before scheduling acquisition and residual evaluation.","summary":"Copy and validate query data before scheduling acquisition and residual evaluation."},"id":"LibTmux::Control::Connection.query-async","kind":"method","modifiers":[],"name":"query-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.query-async","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"default":"Map.new","keywordOnly":true,"name":"$where","optional":true,"type":"Mu"},{"default":"'auto'","keywordOnly":true,"name":"$pushdown","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method query-async(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto',\n                   Mu :$cancel = Cancellation, *%unknown --> Promise:D)","references":[{"end":122,"start":110,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-async","declaration":true},{"text":"(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto',\n                   Mu :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":", *%unknown --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":493,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-query-async"},{"apiScope":"exported","doc":{"body":"Acquire pane observations with explicit source filtering.","summary":"Acquire pane observations with explicit source filtering."},"id":"LibTmux::Control::Connection.query-panes","kind":"method","modifiers":[],"name":"query-panes","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.query-panes","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query-panes(*%options --> PaneSelection:D)","references":[{"end":48,"start":33,"target":"LibTmux::Model::PaneSelection"}],"returns":"PaneSelection:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-panes","declaration":true},{"text":"(*%options --> "},{"text":"PaneSelection:D","target":"LibTmux::Model::PaneSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":511,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-query-panes"},{"apiScope":"exported","doc":{"body":"Read a declared projection through the connection's negotiated codec profile.","summary":"Read a declared projection through the connection's negotiated codec profile."},"id":"LibTmux::Control::Connection.read","kind":"method","modifiers":[],"name":"read","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.read","signatures":[{"params":[{"keywordOnly":false,"name":"$projection","optional":false,"type":"Projection:D"},{"keywordOnly":false,"name":"$listing","optional":false,"type":"Invocation:D"},{"keywordOnly":true,"name":"$incarnation","optional":false,"type":"Incarnation:D"},{"default":"Instant","keywordOnly":true,"name":"$deadline","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true}],"raw":"method read(Projection:D $projection, Invocation:D $listing,\n    Incarnation:D :$incarnation!, :$deadline = Instant, :$cancel = Cancellation --> List:D)","references":[{"end":24,"start":12,"target":"LibTmux::Format::Projection"},{"end":50,"start":38,"target":"LibTmux::Command::Invocation"},{"end":78,"start":65,"target":"LibTmux::Engine::Incarnation"},{"end":140,"start":128,"target":"LibTmux::Transport::Cancellation"}],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"read","declaration":true},{"text":"("},{"text":"Projection:D","target":"LibTmux::Format::Projection"},{"text":" $projection, "},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $listing,\n    "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":" :$incarnation!, :$deadline = Instant, :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> List:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":440,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-read"},{"apiScope":"exported","doc":{"body":"Whether the owned control client has exited and been joined.","summary":"Whether the owned control client has exited and been joined."},"id":"LibTmux::Control::Connection.reaped","kind":"method","modifiers":[],"name":"reaped","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.reaped","signatures":[{"params":[],"raw":"method reaped(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"reaped","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":153,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-reaped"},{"apiScope":"exported","doc":{"body":"Session used for the initial attach; explicit client switching can later change it.","summary":"Session used for the initial attach; explicit client switching can later change it."},"id":"LibTmux::Control::Connection.session-id","kind":"property","modifiers":[],"name":"session-id","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.session-id","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":91,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SessionId:D","slug":"libtmux-control-connection-session-id"},{"apiScope":"exported","doc":{"body":"Acquire a fresh graph through this connection; retained views keep no connection alive.","summary":"Acquire a fresh graph through this connection; retained views keep no connection alive."},"id":"LibTmux::Control::Connection.snapshot","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.snapshot","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D)","references":[{"end":28,"start":16,"target":"LibTmux::Transport::Cancellation"},{"end":52,"start":40,"target":"LibTmux::Transport::Cancellation"},{"end":67,"start":57,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":477,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-snapshot"},{"apiScope":"exported","doc":{"body":"Resolve a fresh graph acquired within one deadline, with explicit cancellation.","summary":"Resolve a fresh graph acquired within one deadline, with explicit cancellation."},"id":"LibTmux::Control::Connection.snapshot-async","kind":"method","modifiers":[],"name":"snapshot-async","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.snapshot-async","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method snapshot-async(Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":34,"start":22,"target":"LibTmux::Transport::Cancellation"},{"end":58,"start":46,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot-async","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":479,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-snapshot-async"},{"apiScope":"exported","doc":{"body":"Default request deadline budget in milliseconds from admission.","summary":"Default request deadline budget in milliseconds from admission."},"id":"LibTmux::Control::Connection.timeout-ms","kind":"property","modifiers":[],"name":"timeout-ms","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.timeout-ms","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":93,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-connection-timeout-ms"},{"apiScope":"exported","doc":{"body":"Validate an encoded command against this connection without I/O or queue admission.","summary":"Validate an encoded command against this connection without I/O or queue admission."},"id":"LibTmux::Control::Connection.validate-command","kind":"method","modifiers":[],"name":"validate-command","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection.validate-command","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"keywordOnly":true,"name":"$incarnation","optional":false,"type":"Incarnation:D"}],"raw":"method validate-command(Invocation:D $command, Incarnation:D :$incarnation! --> Nil)","references":[{"end":36,"start":24,"target":"LibTmux::Command::Invocation"},{"end":60,"start":47,"target":"LibTmux::Engine::Incarnation"}],"returns":"Nil","nativeSyntax":[{"start":7,"end":23,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"validate-command","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":" :$incarnation! --> Nil)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":407,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-validate-command"},{"apiScope":"exported","doc":{"body":"Ordered command records observed before a separate queue barrier completed.","summary":"Ordered command records observed before a separate queue barrier completed."},"id":"LibTmux::Control::Connection::Acknowledgement","kind":"class","modifiers":[],"name":"Acknowledgement","package":"LibTmux","parent":"LibTmux::Control::Connection","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-acknowledgement"},{"apiScope":"exported","doc":{"body":"Refuse altered copies of this received acknowledgement.","summary":"Refuse altered copies of this received acknowledgement."},"id":"LibTmux::Control::Connection::Acknowledgement.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-acknowledgement-clone"},{"apiScope":"exported","doc":{"body":"Unique connection identity; reconnecting always creates a new epoch.","summary":"Unique connection identity; reconnecting always creates a new epoch."},"id":"LibTmux::Control::Connection::Acknowledgement.epoch","kind":"property","modifiers":[],"name":"epoch","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.epoch","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-control-connection-acknowledgement-epoch"},{"apiScope":"exported","doc":{"body":"Whether any framed response ended with a command error guard.","summary":"Whether any framed response ended with a command error guard."},"id":"LibTmux::Control::Connection::Acknowledgement.failed","kind":"method","modifiers":[],"name":"failed","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.failed","signatures":[{"params":[],"raw":"method failed(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"failed","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":44,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-acknowledgement-failed"},{"apiScope":"exported","doc":{"body":"Retained protocol payload bytes, excluding bounded record metadata.","summary":"Retained protocol payload bytes, excluding bounded record metadata."},"id":"LibTmux::Control::Connection::Acknowledgement.output-bytes","kind":"method","modifiers":[],"name":"output-bytes","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.output-bytes","signatures":[{"params":[],"raw":"method output-bytes(--> Count:D)","references":[{"end":31,"start":24,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"output-bytes","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":46,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-acknowledgement-output-bytes"},{"apiScope":"exported","doc":{"body":"Copy response and unframed payload bytes in their received order.","summary":"Copy response and unframed payload bytes in their received order."},"id":"LibTmux::Control::Connection::Acknowledgement.payload","kind":"method","modifiers":[],"name":"payload","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.payload","signatures":[{"params":[],"raw":"method payload(--> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"payload","declaration":true},{"text":"(--> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":50,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-connection-acknowledgement-payload"},{"apiScope":"exported","doc":{"body":"Ordered response blocks and unframed output preceding the completion barrier.","summary":"Ordered response blocks and unframed output preceding the completion barrier."},"id":"LibTmux::Control::Connection::Acknowledgement.records","kind":"property","modifiers":[],"name":"records","package":"LibTmux","parent":"LibTmux::Control::Connection::Acknowledgement","product":"core","publicId":"LibTmux::Control::Connection::Acknowledgement.records","signatures":[],"source":{"file":"lib/LibTmux/Control/Connection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-control-connection-acknowledgement-records"},{"apiScope":"exported","doc":{"body":"Incremental LF framing with exact response guards and bounded retained data.","summary":"Incremental LF framing with exact response guards and bounded retained data."},"id":"LibTmux::Control::Decoder","kind":"class","modifiers":[],"name":"Decoder","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::Decoder","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":108,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-decoder"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::Decoder.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":126,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-decoder-clone"},{"apiScope":"exported","doc":{"body":"Return complete events/responses in arrival order; partial records stay bounded.","summary":"Return complete events/responses in arrival order; partial records stay bounded."},"id":"LibTmux::Control::Decoder.feed","kind":"method","modifiers":[],"name":"feed","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.feed","signatures":[{"params":[{"keywordOnly":false,"name":"$chunk","optional":false,"type":"Blob:D"}],"raw":"method feed(Blob:D $chunk --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"feed","declaration":true},{"text":"(Blob:D $chunk --> List:D)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":167,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-decoder-feed"},{"apiScope":"exported","doc":{"body":"EOF is valid only between complete notifications and command blocks.","summary":"EOF is valid only between complete notifications and command blocks."},"id":"LibTmux::Control::Decoder.finish","kind":"method","modifiers":[],"name":"finish","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.finish","signatures":[{"params":[],"raw":"method finish(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"finish","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":192,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-decoder-finish"},{"apiScope":"exported","doc":{"body":"Maximum bytes accepted in one feed call.","summary":"Maximum bytes accepted in one feed call."},"id":"LibTmux::Control::Decoder.max-chunk-bytes","kind":"property","modifiers":[],"name":"max-chunk-bytes","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.max-chunk-bytes","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":114,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-decoder-max-chunk-bytes"},{"apiScope":"exported","doc":{"body":"Maximum completed frames emitted by one feed call.","summary":"Maximum completed frames emitted by one feed call."},"id":"LibTmux::Control::Decoder.max-frames","kind":"property","modifiers":[],"name":"max-frames","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.max-frames","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":116,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-decoder-max-frames"},{"apiScope":"exported","doc":{"body":"Maximum incomplete or complete physical control line length in bytes.","summary":"Maximum incomplete or complete physical control line length in bytes."},"id":"LibTmux::Control::Decoder.max-line-bytes","kind":"property","modifiers":[],"name":"max-line-bytes","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.max-line-bytes","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":110,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-decoder-max-line-bytes"},{"apiScope":"exported","doc":{"body":"Maximum payload bytes retained inside one response block.","summary":"Maximum payload bytes retained inside one response block."},"id":"LibTmux::Control::Decoder.max-response-bytes","kind":"property","modifiers":[],"name":"max-response-bytes","package":"LibTmux","parent":"LibTmux::Control::Decoder","product":"core","publicId":"LibTmux::Control::Decoder.max-response-bytes","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":112,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-control-decoder-max-response-bytes"},{"apiScope":"exported","doc":{"body":"One notification, retaining its original bytes without the record terminator.","summary":"One notification, retaining its original bytes without the record terminator."},"id":"LibTmux::Control::Event","kind":"class","modifiers":[],"name":"Event","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::Event","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":13,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-event"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::Event.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::Event","product":"core","publicId":"LibTmux::Control::Event.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-event-clone"},{"apiScope":"exported","doc":{"body":"Notification name or unframed-output kind, without assuming a known event schema.","summary":"Notification name or unframed-output kind, without assuming a known event schema."},"id":"LibTmux::Control::Event.kind","kind":"property","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Control::Event","product":"core","publicId":"LibTmux::Control::Event.kind","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":15,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-control-event-kind"},{"apiScope":"exported","doc":{"body":"Original physical record bytes with the terminating LF removed.","summary":"Original physical record bytes with the terminating LF removed."},"id":"LibTmux::Control::Event.raw","kind":"property","modifiers":[],"name":"raw","package":"LibTmux","parent":"LibTmux::Control::Event","product":"core","publicId":"LibTmux::Control::Event.raw","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-control-event-raw"},{"apiScope":"exported","doc":{"body":"Pane output is terminal bytes, not an independently decodable UTF-8 string.","summary":"Pane output is terminal bytes, not an independently decodable UTF-8 string."},"extends":["LibTmux::Control::Event"],"id":"LibTmux::Control::PaneOutput","kind":"class","modifiers":[],"name":"PaneOutput","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::PaneOutput","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":30,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-paneoutput"},{"apiScope":"exported","doc":{"body":"Extended-output age in milliseconds; undefined for ordinary output events.","summary":"Extended-output age in milliseconds; undefined for ordinary output events."},"id":"LibTmux::Control::PaneOutput.age-ms","kind":"property","modifiers":[],"name":"age-ms","package":"LibTmux","parent":"LibTmux::Control::PaneOutput","product":"core","publicId":"LibTmux::Control::PaneOutput.age-ms","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count","slug":"libtmux-control-paneoutput-age-ms"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::PaneOutput.clone","inheritedFrom":"LibTmux::Control::Event","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::PaneOutput","product":"core","publicId":"LibTmux::Control::PaneOutput.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-paneoutput-clone"},{"apiScope":"exported","doc":{"body":"Decoded terminal bytes, which may contain NUL or partial UTF-8 sequences.","summary":"Decoded terminal bytes, which may contain NUL or partial UTF-8 sequences."},"id":"LibTmux::Control::PaneOutput.data","kind":"property","modifiers":[],"name":"data","package":"LibTmux","parent":"LibTmux::Control::PaneOutput","product":"core","publicId":"LibTmux::Control::PaneOutput.data","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":34,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-control-paneoutput-data"},{"apiScope":"exported","doc":{"body":"Pane identity from the notification, scoped to its owning connection.","summary":"Pane identity from the notification, scoped to its owning connection."},"id":"LibTmux::Control::PaneOutput.pane-id","kind":"property","modifiers":[],"name":"pane-id","package":"LibTmux","parent":"LibTmux::Control::PaneOutput","product":"core","publicId":"LibTmux::Control::PaneOutput.pane-id","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"PaneId:D","slug":"libtmux-control-paneoutput-pane-id"},{"apiScope":"exported","doc":{"body":"A matched command guard pair acknowledges execution, not asynchronous effects.","summary":"A matched command guard pair acknowledges execution, not asynchronous effects."},"id":"LibTmux::Control::Response","kind":"class","modifiers":[],"name":"Response","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::Response","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-response"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::Response.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":54,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-response-clone"},{"apiScope":"exported","doc":{"body":"Whether the matching terminal guard was percent-error.","summary":"Whether the matching terminal guard was percent-error."},"id":"LibTmux::Control::Response.failed","kind":"property","modifiers":[],"name":"failed","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.failed","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-control-response-failed"},{"apiScope":"exported","doc":{"body":"Native guard flags; these are not an operation-completion guarantee.","summary":"Native guard flags; these are not an operation-completion guarantee."},"id":"LibTmux::Control::Response.flags","kind":"property","modifiers":[],"name":"flags","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.flags","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-control-response-flags"},{"apiScope":"exported","doc":{"body":"Command number from the matched begin/end or error guard.","summary":"Command number from the matched begin/end or error guard."},"id":"LibTmux::Control::Response.number","kind":"property","modifiers":[],"name":"number","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.number","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-control-response-number"},{"apiScope":"exported","doc":{"body":"Response bytes between matching guards, retaining their line separators.","summary":"Response bytes between matching guards, retaining their line separators."},"id":"LibTmux::Control::Response.payload","kind":"property","modifiers":[],"name":"payload","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.payload","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-control-response-payload"},{"apiScope":"exported","doc":{"body":"Guard timestamp in Unix seconds, retained for correlation.","summary":"Guard timestamp in Unix seconds, retained for correlation."},"id":"LibTmux::Control::Response.time","kind":"property","modifiers":[],"name":"time","package":"LibTmux","parent":"LibTmux::Control::Response","product":"core","publicId":"LibTmux::Control::Response.time","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-control-response-time"},{"apiScope":"exported","doc":{"body":"Some queued jobs print after their end guard; preserve that unframed line.","summary":"Some queued jobs print after their end guard; preserve that unframed line."},"extends":["LibTmux::Control::Event"],"id":"LibTmux::Control::UnframedOutput","kind":"class","modifiers":[],"name":"UnframedOutput","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::UnframedOutput","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-unframedoutput"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::UnframedOutput.clone","inheritedFrom":"LibTmux::Control::Event","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::UnframedOutput","product":"core","publicId":"LibTmux::Control::UnframedOutput.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-unframedoutput-clone"},{"apiScope":"exported","doc":{"body":"An unrecognized notification remains inspectable without interpreting its body.","summary":"An unrecognized notification remains inspectable without interpreting its body."},"extends":["LibTmux::Control::Event"],"id":"LibTmux::Control::UnknownEvent","kind":"class","modifiers":[],"name":"UnknownEvent","package":"LibTmux","parent":"LibTmux::Control","product":"core","publicId":"LibTmux::Control::UnknownEvent","signatures":[],"source":{"file":"lib/LibTmux/Control.rakumod","line":24,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-unknownevent"},{"apiScope":"exported","doc":{"body":"Refuse cloning; retain this value or construct a fresh decoder.","summary":"Refuse cloning; retain this value or construct a fresh decoder."},"id":"LibTmux::Control::UnknownEvent.clone","inheritedFrom":"LibTmux::Control::Event","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Control::UnknownEvent","product":"core","publicId":"LibTmux::Control::UnknownEvent.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Control.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-control-unknownevent-clone"},{"apiScope":"exported","doc":{"body":"# Daemon identity and explicit effects\n\nEndpoint captures argv scope and sanitized environment without I/O. Runtime\nowns its executor; Observation and Incarnation retain values only. Observing\ncapabilities reads the daemon's version separately from the client executable.\nPrepared projections and references are bound to that daemon incarnation.\n\nManaged commands check Linux boot ID and process start ticks, then enter one\ntmux command-list branch fenced by PID and tmux start time. A replacement\nbetween those steps is refused unless it reuses the same PID and the same\nsecond-resolution start time. That narrow race remains outside this guarantee.\nPersistent control connections provide a separate, connection-bound lifetime.\n\nIdentity probes use a nonce-bearing invalid command with an equals sign and\nhyphen. They cannot match tmux command-alias keys or trigger display-message\nhooks. Normal dispatch of canonical built-in commands is assumed; this is not\na protocol for authenticating a hostile daemon or rewriting its configuration.\n\nClosing Runtime stops its owned clients. It does not stop the tmux daemon or\nundo effects already performed. ` raw ` preserves execution bounds but provides\nno managed identity or compatibility guarantee. Text passed to a command may\nstill have command-specific FORMAT semantics beyond command-language quoting.","summary":""},"id":"LibTmux::Engine","kind":"module","modifiers":[],"name":"Engine","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Engine","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine"},{"apiScope":"exported","doc":{"body":"Immutable connection settings. Construction performs no tmux operation.","summary":"Immutable connection settings. Construction performs no tmux operation."},"id":"LibTmux::Engine::Endpoint","kind":"class","modifiers":[],"name":"Endpoint","package":"LibTmux","parent":"LibTmux::Engine","product":"core","publicId":"LibTmux::Engine::Endpoint","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":24,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-endpoint"},{"apiScope":"exported","doc":{"body":"Immutable executable/global-argument prefix, including UTF-8 mode.","summary":"Immutable executable/global-argument prefix, including UTF-8 mode."},"id":"LibTmux::Engine::Endpoint.argv","kind":"property","modifiers":[],"name":"argv","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.argv","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":38,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-engine-endpoint-argv"},{"apiScope":"exported","doc":{"body":"Executable name or path used for direct argv invocation.","summary":"Executable name or path used for direct argv invocation."},"id":"LibTmux::Engine::Endpoint.binary","kind":"property","modifiers":[],"name":"binary","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.binary","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":26,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-endpoint-binary"},{"apiScope":"exported","doc":{"body":"Rebuild derived argv and identity when copying configuration.","summary":"Rebuild derived argv and identity when copying configuration."},"id":"LibTmux::Engine::Endpoint.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Endpoint:D)","references":[{"end":37,"start":27,"target":"LibTmux::Engine::Endpoint"}],"returns":"Endpoint:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Endpoint:D","target":"LibTmux::Engine::Endpoint"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Engine.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-endpoint-clone"},{"apiScope":"exported","doc":{"body":"Explicit tmux configuration path; empty leaves the native choice unchanged.","summary":"Explicit tmux configuration path; empty leaves the native choice unchanged."},"id":"LibTmux::Engine::Endpoint.config-file","kind":"property","modifiers":[],"name":"config-file","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.config-file","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-endpoint-config-file"},{"apiScope":"exported","doc":{"body":"Absolute working directory used when launching command clients.","summary":"Absolute working directory used when launching command clients."},"id":"LibTmux::Engine::Endpoint.cwd","kind":"property","modifiers":[],"name":"cwd","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.cwd","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"IO::Path:D","slug":"libtmux-engine-endpoint-cwd"},{"apiScope":"exported","doc":{"body":"Copied child environment with ambient TMUX and TMUX_PANE removed.","summary":"Copied child environment with ambient TMUX and TMUX_PANE removed."},"id":"LibTmux::Engine::Endpoint.environment","kind":"property","modifiers":[],"name":"environment","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.environment","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":34,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Map:D","slug":"libtmux-engine-endpoint-environment"},{"apiScope":"exported","doc":{"body":"Length-delimited endpoint key; this alone does not identify a daemon lifetime.","summary":"Length-delimited endpoint key; this alone does not identify a daemon lifetime."},"id":"LibTmux::Engine::Endpoint.key","kind":"property","modifiers":[],"name":"key","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.key","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":40,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-endpoint-key"},{"apiScope":"exported","doc":{"body":"Validate and copy endpoint settings without contacting tmux.","summary":"Validate and copy endpoint settings without contacting tmux."},"id":"LibTmux::Engine::Endpoint.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.new","signatures":[{"params":[{"default":"'tmux'","keywordOnly":true,"name":"$binary","optional":true},{"default":"''","keywordOnly":true,"name":"$socket-name","optional":true},{"default":"''","keywordOnly":true,"name":"$socket-path","optional":true},{"default":"''","keywordOnly":true,"name":"$config-file","optional":true},{"default":"%*ENV","keywordOnly":true,"name":"$environment","optional":true},{"default":"$*CWD","keywordOnly":true,"name":"$cwd","optional":true}],"raw":"method new(:$binary = 'tmux', :$socket-name = '', :$socket-path = '',\n               :$config-file = '', :$environment = %*ENV, :$cwd = $*CWD)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(:$binary = 'tmux', :$socket-name = '', :$socket-path = '',\n               :$config-file = '', :$environment = %*ENV, :$cwd = $*CWD)"}]}],"source":{"file":"lib/LibTmux/Engine.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-endpoint-new"},{"apiScope":"exported","doc":{"body":"Named tmux socket; empty selects the normal socket policy.","summary":"Named tmux socket; empty selects the normal socket policy."},"id":"LibTmux::Engine::Endpoint.socket-name","kind":"property","modifiers":[],"name":"socket-name","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.socket-name","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-endpoint-socket-name"},{"apiScope":"exported","doc":{"body":"Explicit socket path, resolved against the captured working directory.","summary":"Explicit socket path, resolved against the captured working directory."},"id":"LibTmux::Engine::Endpoint.socket-path","kind":"property","modifiers":[],"name":"socket-path","package":"LibTmux","parent":"LibTmux::Engine::Endpoint","product":"core","publicId":"LibTmux::Engine::Endpoint.socket-path","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":30,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-endpoint-socket-path"},{"apiScope":"exported","doc":{"body":"Value-only daemon identity. Retaining it keeps no process or executor alive.","summary":"Value-only daemon identity. Retaining it keeps no process or executor alive."},"id":"LibTmux::Engine::Incarnation","kind":"class","modifiers":[],"name":"Incarnation","package":"LibTmux","parent":"LibTmux::Engine","product":"core","publicId":"LibTmux::Engine::Incarnation","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":91,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-incarnation"},{"apiScope":"exported","doc":{"body":"Linux boot identifier contributing to process identity.","summary":"Linux boot identifier contributing to process identity."},"id":"LibTmux::Engine::Incarnation.boot-id","kind":"property","modifiers":[],"name":"boot-id","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.boot-id","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":95,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-incarnation-boot-id"},{"apiScope":"exported","doc":{"body":"Exact daemon-reported version text; distinct from client executable version.","summary":"Exact daemon-reported version text; distinct from client executable version."},"id":"LibTmux::Engine::Incarnation.daemon-version","kind":"property","modifiers":[],"name":"daemon-version","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.daemon-version","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":103,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-incarnation-daemon-version"},{"apiScope":"exported","doc":{"body":"Endpoint key observed for this daemon incarnation.","summary":"Endpoint key observed for this daemon incarnation."},"id":"LibTmux::Engine::Incarnation.endpoint-key","kind":"property","modifiers":[],"name":"endpoint-key","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.endpoint-key","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":93,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-engine-incarnation-endpoint-key"},{"apiScope":"exported","doc":{"body":"Return the length-delimited identity key without I/O.","summary":"Return the length-delimited identity key without I/O."},"id":"LibTmux::Engine::Incarnation.key","kind":"method","modifiers":[],"name":"key","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.key","signatures":[{"params":[],"raw":"method key(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"key","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Engine.rakumod","line":106,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-incarnation-key"},{"apiScope":"exported","doc":{"body":"Observed daemon process ID, combined with boot and start evidence.","summary":"Observed daemon process ID, combined with boot and start evidence."},"id":"LibTmux::Engine::Incarnation.pid","kind":"property","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.pid","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":97,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-engine-incarnation-pid"},{"apiScope":"exported","doc":{"body":"Linux process start counter in kernel clock ticks.","summary":"Linux process start counter in kernel clock ticks."},"id":"LibTmux::Engine::Incarnation.start-ticks","kind":"property","modifiers":[],"name":"start-ticks","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.start-ticks","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":99,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-engine-incarnation-start-ticks"},{"apiScope":"exported","doc":{"body":"Daemon-reported start time in Unix seconds, used by the command fence.","summary":"Daemon-reported start time in Unix seconds, used by the command fence."},"id":"LibTmux::Engine::Incarnation.start-time","kind":"property","modifiers":[],"name":"start-time","package":"LibTmux","parent":"LibTmux::Engine::Incarnation","product":"core","publicId":"LibTmux::Engine::Incarnation.start-time","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":101,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-engine-incarnation-start-time"},{"apiScope":"exported","doc":{"body":"One immutable pairing of daemon identity and capability evidence.","summary":"One immutable pairing of daemon identity and capability evidence."},"id":"LibTmux::Engine::Observation","kind":"class","modifiers":[],"name":"Observation","package":"LibTmux","parent":"LibTmux::Engine","product":"core","publicId":"LibTmux::Engine::Observation","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":113,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-observation"},{"apiScope":"exported","doc":{"body":"Immutable capability evidence bound to the same daemon incarnation.","summary":"Immutable capability evidence bound to the same daemon incarnation."},"id":"LibTmux::Engine::Observation.capabilities","kind":"property","modifiers":[],"name":"capabilities","package":"LibTmux","parent":"LibTmux::Engine::Observation","product":"core","publicId":"LibTmux::Engine::Observation.capabilities","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":117,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"LibTmux::Capabilities:D","slug":"libtmux-engine-observation-capabilities"},{"apiScope":"exported","doc":{"body":"Reconstruct a validated immutable observation from copied values.","summary":"Reconstruct a validated immutable observation from copied values."},"id":"LibTmux::Engine::Observation.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Engine::Observation","product":"core","publicId":"LibTmux::Engine::Observation.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Observation:D)","references":[{"end":40,"start":27,"target":"LibTmux::Engine::Observation"}],"returns":"Observation:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Observation:D","target":"LibTmux::Engine::Observation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Engine.rakumod","line":127,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-engine-observation-clone"},{"apiScope":"exported","doc":{"body":"Captured daemon identity used to reject references after replacement.","summary":"Captured daemon identity used to reject references after replacement."},"id":"LibTmux::Engine::Observation.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Engine::Observation","product":"core","publicId":"LibTmux::Engine::Observation.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Engine.rakumod","line":115,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Incarnation:D","slug":"libtmux-engine-observation-incarnation"},{"apiScope":"exported","doc":{"body":"Typed acquisition, decoding, query, ownership and command failures.","summary":"Typed acquisition, decoding, query, ownership and command failures."},"id":"LibTmux::Exceptions","kind":"module","modifiers":[],"name":"Exceptions","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Exceptions","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":4,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-exceptions"},{"apiScope":"exported","doc":{"body":"# Declared FORMAT projections\nA Projection validates ordered catalogue field names, acquisition context,\ncapabilities, and nullable-field dependencies before generating a template.\nIts schema identifies the field order, codec, and output-repair profile.\nThe separately retained incarnation binds a prepared projection to a daemon;\nthe engine validates that identity before dispatch.\n\nFeed binary output to FrameDecoder and call finish at process completion.\nAn incomplete record, malformed token, exceeded bound, or mismatched schema\nthrows X::LibTmux::Decode and closes the decoder. Row numbers start at one;\noffsets count bytes from the start of the response. Field conversion errors\nidentify the field's starting offset; token errors locate the offending byte.\n\nDecodedRow.bytes retains exact immutable payload bytes. Its value method\nperforms strict UTF-8 conversion for text only when requested. State reports\ndomain null independently from a present empty string, zero, or false.\nRows are constructed through Projection.decode-row and retain the projection's\ndaemon identity as a string; they do not retain an executor or connection.\nAn empty raw q/a token is accepted only when its declared null policy and\nprojected dependencies establish domain null; present empty text remains quoted.\nNo decoding stage evaluates tmux commands, shell syntax, or Raku source.","summary":""},"id":"LibTmux::Format","kind":"module","modifiers":[],"name":"Format","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Format","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format"},{"apiScope":"exported","doc":{"body":"Exact captured field bytes and scalar values. Text conversion is explicit.","summary":"Exact captured field bytes and scalar values. Text conversion is explicit."},"id":"LibTmux::Format::DecodedRow","kind":"class","modifiers":[],"name":"DecodedRow","package":"LibTmux","parent":"LibTmux::Format","product":"core","publicId":"LibTmux::Format::DecodedRow","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":159,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow"},{"apiScope":"exported","doc":{"body":"Return immutable bytes before Unicode normalization, including invalid UTF-8.","summary":"Return immutable bytes before Unicode normalization, including invalid UTF-8."},"id":"LibTmux::Format::DecodedRow.bytes","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":221,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow-bytes"},{"apiScope":"exported","doc":{"body":"Copy an observation without substituting unvalidated field state.","summary":"Copy an observation without substituting unvalidated field state."},"id":"LibTmux::Format::DecodedRow.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> DecodedRow:D)","references":[{"end":39,"start":27,"target":"LibTmux::Format::DecodedRow"}],"returns":"DecodedRow:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"DecodedRow:D","target":"LibTmux::Format::DecodedRow"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":209,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow-clone"},{"apiScope":"exported","doc":{"body":"Daemon key used to scope this projection or decoded row.","summary":"Daemon key used to scope this projection or decoded row."},"id":"LibTmux::Format::DecodedRow.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":163,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-decodedrow-incarnation"},{"apiScope":"exported","doc":{"body":"Refuse direct construction; rows must come from Projection.decode-row.","summary":"Refuse direct construction; rows must come from Projection.decode-row."},"id":"LibTmux::Format::DecodedRow.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":173,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow-new"},{"apiScope":"exported","doc":{"body":"Immutable map of field names to their decoded original bytes.","summary":"Immutable map of field names to their decoded original bytes."},"id":"LibTmux::Format::DecodedRow.raw","kind":"property","modifiers":[],"name":"raw","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.raw","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":167,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Map:D","slug":"libtmux-format-decodedrow-raw"},{"apiScope":"exported","doc":{"body":"One-based record number used in decode diagnostics.","summary":"One-based record number used in decode diagnostics."},"id":"LibTmux::Format::DecodedRow.row","kind":"property","modifiers":[],"name":"row","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.row","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":165,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-format-decodedrow-row"},{"apiScope":"exported","doc":{"body":"Versioned projection identity, including entity and acquisition context.","summary":"Versioned projection identity, including entity and acquisition context."},"id":"LibTmux::Format::DecodedRow.schema","kind":"property","modifiers":[],"name":"schema","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.schema","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":161,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-decodedrow-schema"},{"apiScope":"exported","doc":{"body":"Distinguish domain null from a present empty value.","summary":"Distinguish domain null from a present empty value."},"id":"LibTmux::Format::DecodedRow.state","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":227,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow-state"},{"apiScope":"exported","doc":{"body":"Return a typed scalar or strict Unicode text; known domain null returns Nil.","summary":"Return a typed scalar or strict Unicode text; known domain null returns Nil."},"id":"LibTmux::Format::DecodedRow.value","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Format::DecodedRow","product":"core","publicId":"LibTmux::Format::DecodedRow.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":233,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-decodedrow-value"},{"apiScope":"exported","doc":{"body":"Incremental LF framing over bytes with terminal failure and explicit limits.","summary":"Incremental LF framing over bytes with terminal failure and explicit limits."},"id":"LibTmux::Format::FrameDecoder","kind":"class","modifiers":[],"name":"FrameDecoder","package":"LibTmux","parent":"LibTmux::Format","product":"core","publicId":"LibTmux::Format::FrameDecoder","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":438,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-framedecoder"},{"apiScope":"exported","doc":{"body":"A new stream needs a new decoder; buffered state cannot be shallow-copied.","summary":"A new stream needs a new decoder; buffered state cannot be shallow-copied."},"id":"LibTmux::Format::FrameDecoder.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":455,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-framedecoder-clone"},{"apiScope":"exported","doc":{"body":"Yield complete decoded rows eagerly; incomplete bytes remain owned here.","summary":"Yield complete decoded rows eagerly; incomplete bytes remain owned here."},"id":"LibTmux::Format::FrameDecoder.feed","kind":"method","modifiers":[],"name":"feed","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.feed","signatures":[{"params":[{"keywordOnly":false,"name":"$chunk","optional":false,"type":"Blob:D"}],"raw":"method feed(Blob:D $chunk --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"feed","declaration":true},{"text":"(Blob:D $chunk --> List:D)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":461,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-framedecoder-feed"},{"apiScope":"exported","doc":{"body":"Close successfully only on a complete record boundary.","summary":"Close successfully only on a complete record boundary."},"id":"LibTmux::Format::FrameDecoder.finish","kind":"method","modifiers":[],"name":"finish","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.finish","signatures":[{"params":[],"raw":"method finish(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"finish","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":487,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-framedecoder-finish"},{"apiScope":"exported","doc":{"body":"Maximum incomplete record bytes retained between feed calls.","summary":"Maximum incomplete record bytes retained between feed calls."},"id":"LibTmux::Format::FrameDecoder.max-buffer-bytes","kind":"property","modifiers":[],"name":"max-buffer-bytes","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.max-buffer-bytes","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":444,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-format-framedecoder-max-buffer-bytes"},{"apiScope":"exported","doc":{"body":"Maximum cumulative response bytes accepted by this decoder.","summary":"Maximum cumulative response bytes accepted by this decoder."},"id":"LibTmux::Format::FrameDecoder.max-bytes","kind":"property","modifiers":[],"name":"max-bytes","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.max-bytes","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":442,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-format-framedecoder-max-bytes"},{"apiScope":"exported","doc":{"body":"Maximum encoded field size in bytes.","summary":"Maximum encoded field size in bytes."},"id":"LibTmux::Format::FrameDecoder.max-field-bytes","kind":"property","modifiers":[],"name":"max-field-bytes","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.max-field-bytes","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":446,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-format-framedecoder-max-field-bytes"},{"apiScope":"exported","doc":{"body":"Maximum complete records accepted before finish.","summary":"Maximum complete records accepted before finish."},"id":"LibTmux::Format::FrameDecoder.max-rows","kind":"property","modifiers":[],"name":"max-rows","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.max-rows","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":448,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-format-framedecoder-max-rows"},{"apiScope":"exported","doc":{"body":"Declared projection used to frame and decode every accepted record.","summary":"Declared projection used to frame and decode every accepted record."},"id":"LibTmux::Format::FrameDecoder.projection","kind":"property","modifiers":[],"name":"projection","package":"LibTmux","parent":"LibTmux::Format::FrameDecoder","product":"core","publicId":"LibTmux::Format::FrameDecoder.projection","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":440,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Projection:D","slug":"libtmux-format-framedecoder-projection"},{"apiScope":"exported","doc":{"body":"Ordered registered fields with an explicit acquisition context and codec.","summary":"Ordered registered fields with an explicit acquisition context and codec."},"id":"LibTmux::Format::Projection","kind":"class","modifiers":[],"name":"Projection","package":"LibTmux","parent":"LibTmux::Format","product":"core","publicId":"LibTmux::Format::Projection","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":243,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-projection"},{"apiScope":"exported","doc":{"body":"Reconfigured projections must pass the catalogue and capability constructor.","summary":"Reconfigured projections must pass the catalogue and capability constructor."},"id":"LibTmux::Format::Projection.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Projection:D)","references":[{"end":39,"start":27,"target":"LibTmux::Format::Projection"}],"returns":"Projection:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Projection:D","target":"LibTmux::Format::Projection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":262,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-projection-clone"},{"apiScope":"exported","doc":{"body":"Source-qualified quoting profile used to encode free-text fields.","summary":"Source-qualified quoting profile used to encode free-text fields."},"id":"LibTmux::Format::Projection.codec-profile","kind":"property","modifiers":[],"name":"codec-profile","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.codec-profile","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":251,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-codec-profile"},{"apiScope":"exported","doc":{"body":"Acquisition context which determines field availability.","summary":"Acquisition context which determines field availability."},"id":"LibTmux::Format::Projection.context","kind":"property","modifiers":[],"name":"context","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.context","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":247,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-context"},{"apiScope":"exported","doc":{"body":"Decode one terminated row's contents. FrameDecoder owns stream boundaries.","summary":"Decode one terminated row's contents. FrameDecoder owns stream boundaries."},"id":"LibTmux::Format::Projection.decode-row","kind":"method","modifiers":[],"name":"decode-row","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.decode-row","signatures":[{"params":[{"keywordOnly":false,"name":"$line","optional":false,"type":"Blob:D"},{"default":"1","keywordOnly":true,"name":"$row","optional":true,"type":"Int:D"},{"default":"0","keywordOnly":true,"name":"$offset","optional":true,"type":"Int:D"},{"default":"1024 * 1024","keywordOnly":true,"name":"$max-field-bytes","optional":true,"type":"Positive:D"}],"raw":"method decode-row(Blob:D $line, Int:D :$row = 1, Int:D :$offset = 0,\n                      Positive:D :$max-field-bytes = 1024 * 1024 --> DecodedRow:D)","references":[{"end":101,"start":91,"target":"LibTmux::Types::Positive"},{"end":150,"start":138,"target":"LibTmux::Format::DecodedRow"}],"returns":"DecodedRow:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"decode-row","declaration":true},{"text":"(Blob:D $line, Int:D :$row = 1, Int:D :$offset = 0,\n                      "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$max-field-bytes = 1024 * 1024 --> "},{"text":"DecodedRow:D","target":"LibTmux::Format::DecodedRow"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":344,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-projection-decode-row"},{"apiScope":"exported","doc":{"body":"Entity schema selected from the authoritative field catalogue.","summary":"Entity schema selected from the authoritative field catalogue."},"id":"LibTmux::Format::Projection.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.entity","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":245,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-entity"},{"apiScope":"exported","doc":{"body":"Ordered declared fields; their order defines the wire record.","summary":"Ordered declared fields; their order defines the wire record."},"id":"LibTmux::Format::Projection.fields","kind":"property","modifiers":[],"name":"fields","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.fields","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":249,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-format-projection-fields"},{"apiScope":"exported","doc":{"body":"Daemon key used to scope this projection or decoded row.","summary":"Daemon key used to scope this projection or decoded row."},"id":"LibTmux::Format::Projection.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":255,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-incarnation"},{"apiScope":"exported","doc":{"body":"Construct a validated projection; decoded rows must instead come from decode-row.","summary":"Construct a validated projection; decoded rows must instead come from decode-row."},"id":"LibTmux::Format::Projection.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.new","signatures":[{"params":[{"keywordOnly":true,"name":"$entity","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$fields","optional":false,"type":"Positional:D"},{"keywordOnly":true,"name":"$capabilities","optional":false,"type":"LibTmux::Capabilities:D"},{"keywordOnly":true,"name":"$context","optional":true,"type":"Str"}],"raw":"method new(Str:D :$entity!, Positional:D :$fields!,\n               LibTmux::Capabilities:D :$capabilities!, Str :$context)","references":[{"end":90,"start":67,"target":"LibTmux::Capabilities"}],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(Str:D :$entity!, Positional:D :$fields!,\n               "},{"text":"LibTmux::Capabilities:D","target":"LibTmux::Capabilities"},{"text":" :$capabilities!, Str :$context)"}]}],"source":{"file":"lib/LibTmux/Format.rakumod","line":268,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-format-projection-new"},{"apiScope":"exported","doc":{"body":"Declared command-output repair policy applied before field decoding.","summary":"Declared command-output repair policy applied before field decoding."},"id":"LibTmux::Format::Projection.output-repair","kind":"property","modifiers":[],"name":"output-repair","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.output-repair","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":253,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-output-repair"},{"apiScope":"exported","doc":{"body":"Versioned projection identity, including entity and acquisition context.","summary":"Versioned projection identity, including entity and acquisition context."},"id":"LibTmux::Format::Projection.schema","kind":"property","modifiers":[],"name":"schema","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.schema","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":257,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-schema"},{"apiScope":"exported","doc":{"body":"Complete tmux FORMAT template with versioned framing and escaped text fields.","summary":"Complete tmux FORMAT template with versioned framing and escaped text fields."},"id":"LibTmux::Format::Projection.template","kind":"property","modifiers":[],"name":"template","package":"LibTmux","parent":"LibTmux::Format::Projection","product":"core","publicId":"LibTmux::Format::Projection.template","signatures":[],"source":{"file":"lib/LibTmux/Format.rakumod","line":259,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-format-projection-template"},{"apiScope":"exported","doc":{"body":"# Observed layouts\nConstruct layouts and their cells through ` decode-layout `; direct ` new `\ncalls are refused so captured bytes and validated structure stay together.\n\nClassic layouts validate their checksum and represented tiled tree; ` 0000, `\nis the compatibility sentinel for no represented tiled cells. It does not\nprove the physical window lacks floating panes. JSON version 2 retains\nall cells, including floating placements with signed coordinates and z-index.\nThe separate ` window_modal_pane ` observation supplies ` :modal-pane-id `; an\nempty string means known absence, while omission means not acquired.\n\nUnknown dialects and versions expose exact immutable ` raw ` bytes and\n` known == False `. They do not fabricate a tiled interpretation. Parsing and\ntraversal perform no I/O. Input bytes, nesting, numeric spelling and node\ncounts are bounded before or during parsing.","summary":""},"id":"LibTmux::Layout","kind":"module","modifiers":[],"name":"Layout","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Layout","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout"},{"apiScope":"exported","doc":{"body":"Decode a declared dialect. Unknown versions retain bytes without a guessed tree.","summary":"Decode a declared dialect. Unknown versions retain bytes without a guessed tree."},"id":"LibTmux::Layout.decode-layout","kind":"function","modifiers":["overload"],"name":"decode-layout","package":"LibTmux","parent":"LibTmux::Layout","product":"core","publicId":"LibTmux::Layout.decode-layout","signatures":[{"params":[{"keywordOnly":false,"name":"$raw","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"sub decode-layout(Str:D $raw, *%options --> Layout:D)","references":[{"end":52,"start":44,"target":"LibTmux::Layout::Layout"}],"returns":"Layout:D","nativeSyntax":[{"start":4,"end":17,"kind":"name"}],"nativeSpans":[{"text":"sub "},{"text":"decode-layout","declaration":true},{"text":"(Str:D $raw, *%options --> "},{"text":"Layout:D","target":"LibTmux::Layout::Layout"},{"text":")"}]},{"params":[{"keywordOnly":false,"name":"$raw","optional":false,"type":"Blob:D"},{"keywordOnly":true,"name":"$profile","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$modal-pane-id","optional":true,"type":"Str"},{"default":"1024 * 1024","keywordOnly":true,"name":"$max-bytes","optional":true,"type":"Positive:D"},{"default":"64","keywordOnly":true,"name":"$max-depth","optional":true,"type":"Positive:D"},{"default":"10000","keywordOnly":true,"name":"$max-nodes","optional":true,"type":"Positive:D"}],"raw":"sub decode-layout(Blob:D $raw, Str:D :$profile!,\n                        Str :$modal-pane-id,\n                        Positive:D :$max-bytes = 1024 * 1024,\n                        Positive:D :$max-depth = 64,\n                        Positive:D :$max-nodes = 10000 --> Layout:D)","references":[{"end":128,"start":118,"target":"LibTmux::Types::Positive"},{"end":190,"start":180,"target":"LibTmux::Types::Positive"},{"end":243,"start":233,"target":"LibTmux::Types::Positive"},{"end":276,"start":268,"target":"LibTmux::Layout::Layout"}],"returns":"Layout:D","nativeSyntax":[{"start":4,"end":17,"kind":"name"}],"nativeSpans":[{"text":"sub "},{"text":"decode-layout","declaration":true},{"text":"(Blob:D $raw, Str:D :$profile!,\n                        Str :$modal-pane-id,\n                        "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$max-bytes = 1024 * 1024,\n                        "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$max-depth = 64,\n                        "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$max-nodes = 10000 --> "},{"text":"Layout:D","target":"LibTmux::Layout::Layout"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":282,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-decode-layout"},{"apiScope":"exported","doc":{"body":"Decoded layout plus exact source bytes, including unsupported future versions.","summary":"Decoded layout plus exact source bytes, including unsupported future versions."},"id":"LibTmux::Layout::Layout","kind":"class","modifiers":[],"name":"Layout","package":"LibTmux","parent":"LibTmux::Layout","product":"core","publicId":"LibTmux::Layout::Layout","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout"},{"apiScope":"exported","doc":{"body":"Retain agreement between captured bytes, version, and decoded structure.","summary":"Retain agreement between captured bytes, version, and decoded structure."},"id":"LibTmux::Layout::Layout.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Layout:D)","references":[{"end":35,"start":27,"target":"LibTmux::Layout::Layout"}],"returns":"Layout:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Layout:D","target":"LibTmux::Layout::Layout"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":81,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout-clone"},{"apiScope":"exported","doc":{"body":"Floating placements retain their signed offsets and observed stacking order.","summary":"Floating placements retain their signed offsets and observed stacking order."},"id":"LibTmux::Layout::Layout.floating","kind":"method","modifiers":[],"name":"floating","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.floating","signatures":[{"params":[],"raw":"method floating(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"floating","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":99,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout-floating"},{"apiScope":"exported","doc":{"body":"Whether this representation was decoded into the typed node graph.","summary":"Whether this representation was decoded into the typed node graph."},"id":"LibTmux::Layout::Layout.known","kind":"property","modifiers":[],"name":"known","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.known","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-layout-layout-known"},{"apiScope":"exported","doc":{"body":"Resolve separately acquired modal identity; the layout string does not encode it.","summary":"Resolve separately acquired modal identity; the layout string does not encode it."},"id":"LibTmux::Layout::Layout.modal","kind":"method","modifiers":[],"name":"modal","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.modal","signatures":[{"params":[],"raw":"method modal()","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"modal","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":105,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout-modal"},{"apiScope":"exported","doc":{"body":"Captured modal-pane identity when the acquisition context supplies it.","summary":"Captured modal-pane identity when the acquisition context supplies it."},"id":"LibTmux::Layout::Layout.modal-pane-id","kind":"property","modifiers":[],"name":"modal-pane-id","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.modal-pane-id","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":71,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str","slug":"libtmux-layout-layout-modal-pane-id"},{"apiScope":"exported","doc":{"body":"Availability of modal-pane information, distinct from known absence.","summary":"Availability of modal-pane information, distinct from known absence."},"id":"LibTmux::Layout::Layout.modal-state","kind":"property","modifiers":[],"name":"modal-state","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.modal-state","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":73,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"ValueState:D","slug":"libtmux-layout-layout-modal-state"},{"apiScope":"exported","doc":{"body":"Refuse direct construction; decode source bytes through decode-layout.","summary":"Refuse direct construction; decode source bytes through decode-layout."},"id":"LibTmux::Layout::Layout.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout-new"},{"apiScope":"exported","doc":{"body":"Decoder profile selected by the capability observation.","summary":"Decoder profile selected by the capability observation."},"id":"LibTmux::Layout::Layout.profile","kind":"property","modifiers":[],"name":"profile","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.profile","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-layout-layout-profile"},{"apiScope":"exported","doc":{"body":"Exact layout bytes, retained even when the representation is unsupported.","summary":"Exact layout bytes, retained even when the representation is unsupported."},"id":"LibTmux::Layout::Layout.raw","kind":"property","modifiers":[],"name":"raw","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.raw","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-layout-layout-raw"},{"apiScope":"exported","doc":{"body":"Decoded root cell; undefined when the layout representation is unknown.","summary":"Decoded root cell; undefined when the layout representation is unknown."},"id":"LibTmux::Layout::Layout.root","kind":"property","modifiers":[],"name":"root","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.root","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":69,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"LayoutNode","slug":"libtmux-layout-layout-root"},{"apiScope":"exported","doc":{"body":"Leaf cells which participate in tiling; this is not the complete pane set.","summary":"Leaf cells which participate in tiling; this is not the complete pane set."},"id":"LibTmux::Layout::Layout.tiled","kind":"method","modifiers":[],"name":"tiled","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.tiled","signatures":[{"params":[],"raw":"method tiled(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"tiled","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":93,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layout-tiled"},{"apiScope":"exported","doc":{"body":"Layout representation version when supplied by the modern dialect.","summary":"Layout representation version when supplied by the modern dialect."},"id":"LibTmux::Layout::Layout.version","kind":"property","modifiers":[],"name":"version","package":"LibTmux","parent":"LibTmux::Layout::Layout","product":"core","publicId":"LibTmux::Layout::Layout.version","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":67,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-layout-layout-version"},{"apiScope":"exported","doc":{"body":"An immutable observed layout cell; floating leaves need not tile their parent.","summary":"An immutable observed layout cell; floating leaves need not tile their parent."},"id":"LibTmux::Layout::LayoutNode","kind":"class","modifiers":[],"name":"LayoutNode","package":"LibTmux","parent":"LibTmux::Layout","product":"core","publicId":"LibTmux::Layout::LayoutNode","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":14,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layoutnode"},{"apiScope":"exported","doc":{"body":"Optional active-pane flag from the modern layout representation.","summary":"Optional active-pane flag from the modern layout representation."},"id":"LibTmux::Layout::LayoutNode.active","kind":"property","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.active","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":30,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool","slug":"libtmux-layout-layoutnode-active"},{"apiScope":"exported","doc":{"body":"Captured child cells in source order, including floating placements.","summary":"Captured child cells in source order, including floating placements."},"id":"LibTmux::Layout::LayoutNode.children","kind":"property","modifiers":[],"name":"children","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.children","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-layout-layoutnode-children"},{"apiScope":"exported","doc":{"body":"Retain parsed cell invariants when using native no-argument cloning.","summary":"Retain parsed cell invariants when using native no-argument cloning."},"id":"LibTmux::Layout::LayoutNode.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> LayoutNode:D)","references":[{"end":39,"start":27,"target":"LibTmux::Layout::LayoutNode"}],"returns":"LayoutNode:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"LayoutNode:D","target":"LibTmux::Layout::LayoutNode"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":44,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layoutnode-clone"},{"apiScope":"exported","doc":{"body":"The JSON dialect carries floating placement through an explicit z-index.","summary":"The JSON dialect carries floating placement through an explicit z-index."},"id":"LibTmux::Layout::LayoutNode.floating","kind":"method","modifiers":[],"name":"floating","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.floating","signatures":[{"params":[],"raw":"method floating(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"floating","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":50,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layoutnode-floating"},{"apiScope":"exported","doc":{"body":"Cell height in terminal rows.","summary":"Cell height in terminal rows."},"id":"LibTmux::Layout::LayoutNode.height","kind":"property","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.height","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":20,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-layout-layoutnode-height"},{"apiScope":"exported","doc":{"body":"Optional pane index carried by the modern layout representation.","summary":"Optional pane index carried by the modern layout representation."},"id":"LibTmux::Layout::LayoutNode.index","kind":"property","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.index","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-layout-layoutnode-index"},{"apiScope":"exported","doc":{"body":"Pane leaf or horizontal/vertical container kind in the decoded layout.","summary":"Pane leaf or horizontal/vertical container kind in the decoded layout."},"id":"LibTmux::Layout::LayoutNode.kind","kind":"property","modifiers":[],"name":"kind","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.kind","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-layout-layoutnode-kind"},{"apiScope":"exported","doc":{"body":"Optional index in the previously visited panes list.","summary":"Optional index in the previously visited panes list."},"id":"LibTmux::Layout::LayoutNode.last","kind":"property","modifiers":[],"name":"last","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.last","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-layout-layoutnode-last"},{"apiScope":"exported","doc":{"body":"Refuse direct cell construction; obtain validated cells through decode-layout.","summary":"Refuse direct cell construction; obtain validated cells through decode-layout."},"id":"LibTmux::Layout::LayoutNode.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layoutnode-new"},{"apiScope":"exported","doc":{"body":"Leaf pane identity; undefined for a container.","summary":"Leaf pane identity; undefined for a container."},"id":"LibTmux::Layout::LayoutNode.pane-id","kind":"property","modifiers":[],"name":"pane-id","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.pane-id","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":26,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"PaneId","slug":"libtmux-layout-layoutnode-pane-id"},{"apiScope":"exported","doc":{"body":"All leaf cells, retaining source order including floating leaves.","summary":"All leaf cells, retaining source order including floating leaves."},"id":"LibTmux::Layout::LayoutNode.panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.panes","signatures":[{"params":[],"raw":"method panes(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"panes","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Layout.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-layout-layoutnode-panes"},{"apiScope":"exported","doc":{"body":"Cell width in terminal columns.","summary":"Cell width in terminal columns."},"id":"LibTmux::Layout::LayoutNode.width","kind":"property","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.width","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":18,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-layout-layoutnode-width"},{"apiScope":"exported","doc":{"body":"Horizontal cell offset in terminal columns.","summary":"Horizontal cell offset in terminal columns."},"id":"LibTmux::Layout::LayoutNode.x","kind":"property","modifiers":[],"name":"x","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.x","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":22,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-layout-layoutnode-x"},{"apiScope":"exported","doc":{"body":"Vertical cell offset in terminal rows.","summary":"Vertical cell offset in terminal rows."},"id":"LibTmux::Layout::LayoutNode.y","kind":"property","modifiers":[],"name":"y","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.y","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":24,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-layout-layoutnode-y"},{"apiScope":"exported","doc":{"body":"Optional floating-pane stacking index; undefined for tiled cells.","summary":"Optional floating-pane stacking index; undefined for tiled cells."},"id":"LibTmux::Layout::LayoutNode.z","kind":"property","modifiers":[],"name":"z","package":"LibTmux","parent":"LibTmux::Layout::LayoutNode","product":"core","publicId":"LibTmux::Layout::LayoutNode.z","signatures":[],"source":{"file":"lib/LibTmux/Layout.rakumod","line":34,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"libtmux-layout-layoutnode-z"},{"apiScope":"exported","doc":{"body":"# Captured graph\n\nSnapshot captures observations over an interval. Its field accessors, raw bytes,\nrelations and typed selections perform no I/O. It retains endpoint settings and\nincarnation values, never the Runtime that acquired it. Reference construction\nis local; reference commands create and close a fresh bounded client executor.\n\nPhysical windows and panes are unique by scoped ID. WindowLink represents one\nsession/index association, including repeated links to the same physical window.\nRaw contextual rows preserve their multiplicity. Contradictory duplicate records\nand missing targets in complete collections raise InconsistentSnapshot.\nAn incomplete relation raises MissingData rather than appearing empty.\n\nsame-entity compares daemon-scoped identity. WindowLink has no stable identity\nbetween captures, so its comparison is confined to one captured graph. A link\nreference checks its expected physical window before selecting or unlinking;\nrenumbering between that check and the operation remains a documented race.\n\nWindow.decoded-layout parses captured layout bytes locally. Strict text access\ncan fail for invalid UTF-8 while bytes remains available.\n\n\n\n# Explicit commands\n\nSessionRef.new-window and PaneRef.split/new-floating return references from the\ncommand's declared identity projection. PaneRef.break returns the resulting\nWindowRef; older profiles that omit the identity for a single-pane break use\nan ID-filtered observation afterward. A new observation is acquired only by\ninspect. If the source window has several placements, break requires an\nexplicit :from(WindowLinkRef) so tmux cannot choose which association to move.\nOther mutations return a command Result. Completion means the tmux\nclient completed; pane input processing, rendering and child programs may\ncontinue afterward.\n\nWindowRef.link and WindowLinkRef.move require a destination session and index.\nThey return a WindowLinkRef for that placement. Moving, swapping or unlinking a\nplacement is separate from WindowRef.kill, which destroys the physical window\nand all its links. tmux synchronizes placement changes across grouped sessions;\nunlinking a placement also removes its corresponding peer placements. Physical\nwindow linking prefers the destination session's existing source context when\nthe window is already present there. Link checks and mutations are separate operations;\nconcurrent renumbering can race between them. Cross-daemon targets are rejected.\n\nReferences expose value-only options and hooks facades; SessionRef also exposes\nenvironment. Creating these facades performs no I/O. Their get, set and other\nmethods explicitly acquire or mutate current configuration. See\n:obj:`LibTmux::Configuration <LibTmux::Configuration>` for typed option, environment and command-value rules.\n\nClient.ref creates a ClientRef with the observed name bytes, PID and creation\ntime. inspect requires that identity to remain attached. Client commands are\ninherited from :obj:`LibTmux::Client <LibTmux::Client>`; client disconnection and name reuse can still\nrace between the identity check and the command.\n\nNames and start directories are literal. Names that tmux would silently change\nare refused, and separator support follows the daemon's capability profile.\nPaneRef.set-title quotes one FORMAT expansion; tmux's title validation still\napplies. The low-level command method keeps native tmux argument semantics.\nShell commands passed to creation and respawn run through tmux's shell-command\ncontract. PaneRef.pipe deliberately accepts tmux FORMAT and strftime syntax as\nwell as shell syntax. It closes an existing pipe when called without a command;\n:toggle follows pipe-pane -o, which closes an already open pipe.\n\nLiteral pane input uses send-text and never appends Enter. send-keys accepts\nkey names and a positive :repeat. capture and capture-pending return Blob data\nwithout text conversion or whitespace removal. copy-command sends an explicit\ncopy-mode command; it does not interpret arbitrary text as a key sequence.\nreset queues terminal-state reset followed by history clearing without a client\nroundtrip between them. It is not transactional: failure can leave partial\neffects. reset-terminal only resets terminal state. Running a shell's ` reset `\nprogram is a separate application action: send-text('reset') followed by\nsend-keys('Enter') requests it without promising what the pane application does.\n\nSplit dimensions use :size or :percent exclusively. Percentage splits use the\nsize syntax across profiles, avoiding the known percentage-flag defect. Empty\npane creation selects its documented profile encoding; empty windows require\nthe corresponding capability. Floating creation, movement, stacking, modal\npanes and layout variants have independent capability checks. The defective\nbreak-pane profile is refused before either named or unnamed operations.\n\nSee :obj:`LibTmux::Server <LibTmux::Server>` for endpoint ownership and acquisition,\n:obj:`LibTmux::Selection <LibTmux::Selection>` for captured collection operations, and\n:obj:`LibTmux::Transport <LibTmux::Transport>` for Result and process cancellation contracts.","summary":""},"id":"LibTmux::Model","kind":"module","modifiers":[],"name":"Model","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Model","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model"},{"apiScope":"exported","doc":{"body":"Captured buffer metadata; it does not retain or implicitly load buffer content.","summary":"Captured buffer metadata; it does not retain or implicitly load buffer content."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::Buffer","kind":"class","modifiers":[],"name":"Buffer","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Buffer","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":957,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::Buffer.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Buffer.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-clone"},{"apiScope":"exported","doc":{"body":"Captured ` buffer_created `; local uint access.","summary":"Captured ` buffer_created `; local uint access."},"id":"LibTmux::Model::Buffer.created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.created","signatures":[{"params":[],"raw":"method created(--> Count:D)","references":[{"end":26,"start":19,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"created","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":187,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-created"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Buffer.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` buffer_name `; local text access.","summary":"Captured ` buffer_name `; local text access."},"id":"LibTmux::Model::Buffer.name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.name","signatures":[{"params":[],"raw":"method name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":183,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-name"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::Buffer.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-new"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::Buffer.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::Buffer.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::Buffer.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-same-entity"},{"apiScope":"exported","doc":{"body":"Captured ` buffer_sample `; local text access.","summary":"Captured ` buffer_sample `; local text access."},"id":"LibTmux::Model::Buffer.sample","kind":"method","modifiers":[],"name":"sample","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.sample","signatures":[{"params":[],"raw":"method sample(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sample","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":189,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-sample"},{"apiScope":"exported","doc":{"body":"Captured ` buffer_size `; local uint access.","summary":"Captured ` buffer_size `; local uint access."},"id":"LibTmux::Model::Buffer.size","kind":"method","modifiers":[],"name":"size","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.size","signatures":[{"params":[],"raw":"method size(--> Count:D)","references":[{"end":23,"start":16,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"size","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":185,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-size"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::Buffer.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::Buffer.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::Buffer.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::Buffer","product":"core","publicId":"LibTmux::Model::Buffer.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-buffer-value"},{"apiScope":"exported","doc":{"body":"Replayable typed buffer membership with local filtering.","summary":"Replayable typed buffer membership with local filtering."},"id":"LibTmux::Model::BufferSelection","kind":"class","modifiers":[],"name":"BufferSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::BufferSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":972,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::BufferSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::BufferSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::BufferSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::BufferSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::BufferSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-list-1et0"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::BufferSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::BufferSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::BufferSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::BufferSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::BufferSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::BufferSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::BufferSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::BufferSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::BufferSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::BufferSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::BufferSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-list-m9fk"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::BufferSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::BufferSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::BufferSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::BufferSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::BufferSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::BufferSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::BufferSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::BufferSelection","product":"core","publicId":"LibTmux::Model::BufferSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-bufferselection-where"},{"apiScope":"exported","doc":{"body":"Captured attached-client fields; commands use its separate reference.","summary":"Captured attached-client fields; commands use its separate reference."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::Client","kind":"class","modifiers":[],"name":"Client","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Client","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":947,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client"},{"apiScope":"exported","doc":{"body":"Captured ` client_activity `; local uint access.","summary":"Captured ` client_activity `; local uint access."},"id":"LibTmux::Model::Client.activity","kind":"method","modifiers":[],"name":"activity","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.activity","signatures":[{"params":[],"raw":"method activity(--> Count:D)","references":[{"end":27,"start":20,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"activity","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":161,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-activity"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::Client.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Client.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-clone"},{"apiScope":"exported","doc":{"body":"Captured ` client_control_mode `; local bool access.","summary":"Captured ` client_control_mode `; local bool access."},"id":"LibTmux::Model::Client.control-mode","kind":"method","modifiers":[],"name":"control-mode","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.control-mode","signatures":[{"params":[],"raw":"method control-mode(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"control-mode","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":163,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-control-mode"},{"apiScope":"exported","doc":{"body":"Captured ` client_created `; local uint access.","summary":"Captured ` client_created `; local uint access."},"id":"LibTmux::Model::Client.created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.created","signatures":[{"params":[],"raw":"method created(--> Count:D)","references":[{"end":26,"start":19,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"created","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":159,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-created"},{"apiScope":"exported","doc":{"body":"Captured ` client_height `; local uint access.","summary":"Captured ` client_height `; local uint access."},"id":"LibTmux::Model::Client.height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.height","signatures":[{"params":[],"raw":"method height(--> Count)","references":[{"end":23,"start":18,"target":"LibTmux::Types::Count"}],"returns":"Count","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"height","declaration":true},{"text":"(--> "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":157,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-height"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Client.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` client_key_table `; local text access.","summary":"Captured ` client_key_table `; local text access."},"id":"LibTmux::Model::Client.key-table","kind":"method","modifiers":[],"name":"key-table","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.key-table","signatures":[{"params":[],"raw":"method key-table(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"key-table","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":169,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-key-table"},{"apiScope":"exported","doc":{"body":"Captured ` client_name `; local text access.","summary":"Captured ` client_name `; local text access."},"id":"LibTmux::Model::Client.name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.name","signatures":[{"params":[],"raw":"method name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":145,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-name"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::Client.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-new"},{"apiScope":"exported","doc":{"body":"Captured ` client_pid `; local uint access.","summary":"Captured ` client_pid `; local uint access."},"id":"LibTmux::Model::Client.pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.pid","signatures":[{"params":[],"raw":"method pid(--> Count:D)","references":[{"end":22,"start":15,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pid","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":153,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-pid"},{"apiScope":"exported","doc":{"body":"Captured ` client_readonly `; local bool access.","summary":"Captured ` client_readonly `; local bool access."},"id":"LibTmux::Model::Client.read-only","kind":"method","modifiers":[],"name":"read-only","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.read-only","signatures":[{"params":[],"raw":"method read-only(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"read-only","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":165,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-read-only"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::Client.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::Client.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::Client.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-same-entity"},{"apiScope":"exported","doc":{"body":"The observed associated session, resolved without I/O.","summary":"The observed associated session, resolved without I/O."},"id":"LibTmux::Model::Client.session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.session","signatures":[{"params":[],"raw":"method session(--> Session:D)","references":[{"end":28,"start":19,"target":"LibTmux::Model::Session"}],"returns":"Session:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session","declaration":true},{"text":"(--> "},{"text":"Session:D","target":"LibTmux::Model::Session"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":949,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-session"},{"apiScope":"exported","doc":{"body":"Captured ` session_id `; local session-id access.","summary":"Captured ` session_id `; local session-id access."},"id":"LibTmux::Model::Client.session-id","kind":"method","modifiers":[],"name":"session-id","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.session-id","signatures":[{"params":[],"raw":"method session-id(--> SessionId:D)","references":[{"end":33,"start":22,"target":"LibTmux::Types::SessionId"}],"returns":"SessionId:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session-id","declaration":true},{"text":"(--> "},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":147,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-session-id"},{"apiScope":"exported","doc":{"body":"Captured ` client_session `; local text access.","summary":"Captured ` client_session `; local text access."},"id":"LibTmux::Model::Client.session-name","kind":"method","modifiers":[],"name":"session-name","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.session-name","signatures":[{"params":[],"raw":"method session-name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session-name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":149,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-session-name"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::Client.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::Client.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-state"},{"apiScope":"exported","doc":{"body":"Captured ` client_termname `; local text access.","summary":"Captured ` client_termname `; local text access."},"id":"LibTmux::Model::Client.terminal-name","kind":"method","modifiers":[],"name":"terminal-name","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.terminal-name","signatures":[{"params":[],"raw":"method terminal-name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"terminal-name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":167,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-terminal-name"},{"apiScope":"exported","doc":{"body":"Captured ` client_tty `; local text access.","summary":"Captured ` client_tty `; local text access."},"id":"LibTmux::Model::Client.tty","kind":"method","modifiers":[],"name":"tty","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.tty","signatures":[{"params":[],"raw":"method tty(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"tty","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":151,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-tty"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::Client.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-value"},{"apiScope":"exported","doc":{"body":"Captured ` client_width `; local uint access.","summary":"Captured ` client_width `; local uint access."},"id":"LibTmux::Model::Client.width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Model::Client","product":"core","publicId":"LibTmux::Model::Client.width","signatures":[{"params":[],"raw":"method width(--> Count:D)","references":[{"end":24,"start":17,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"width","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-client-width"},{"apiScope":"exported","doc":{"body":"A captured client identity with explicit inspection and inherited client commands.","summary":"A captured client identity with explicit inspection and inherited client commands."},"extends":["LibTmux::Client::ClientTarget"],"id":"LibTmux::Model::ClientRef","kind":"class","modifiers":[],"name":"ClientRef","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::ClientRef","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":569,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref"},{"apiScope":"exported","doc":{"body":"Enter a pane mode shared by every client viewing that pane.","summary":"Enter a pane mode shared by every client viewing that pane."},"id":"LibTmux::Model::ClientRef.choose","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"choose","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.choose","signatures":[{"params":[{"keywordOnly":false,"name":"$kind","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"Str","keywordOnly":true,"name":"$format","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$filter","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$key-format","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$sort","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$reverse","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$zoom","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$preview","optional":true,"type":"Bool:D"},{"default":"CommandTemplate","keywordOnly":true,"name":"$template","optional":true,"type":"CommandTemplate"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method choose(Str:D $kind, PaneId:D :$pane!, Str :$format = Str,\n                  Str :$filter = Str, Str :$key-format = Str, Str :$sort = Str,\n                  Bool:D :$reverse = False, Bool:D :$zoom = False,\n                  Bool:D :$preview = True, CommandTemplate :$template = CommandTemplate,\n                  *%operation --> Result:D)","references":[{"end":35,"start":27,"target":"LibTmux::Types::PaneId"},{"end":270,"start":255,"target":"LibTmux::Client::CommandTemplate"},{"end":299,"start":284,"target":"LibTmux::Client::CommandTemplate"},{"end":343,"start":335,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"choose","declaration":true},{"text":"(Str:D $kind, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Str :$format = Str,\n                  Str :$filter = Str, Str :$key-format = Str, Str :$sort = Str,\n                  Bool:D :$reverse = False, Bool:D :$zoom = False,\n                  Bool:D :$preview = True, "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":" :$template = "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":",\n                  *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":245,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-choose"},{"apiScope":"exported","doc":{"body":"Clear the daemon's selected prompt history; it is shared across clients.","summary":"Clear the daemon's selected prompt history; it is shared across clients."},"id":"LibTmux::Model::ClientRef.clear-prompt-history","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"clear-prompt-history","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.clear-prompt-history","signatures":[{"params":[{"default":"Str","keywordOnly":true,"name":"$type","optional":true,"type":"Str"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method clear-prompt-history(Str :$type = Str, *%operation --> Result:D)","references":[{"end":70,"start":62,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":27,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clear-prompt-history","declaration":true},{"text":"(Str :$type = Str, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":366,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-clear-prompt-history"},{"apiScope":"exported","doc":{"body":"Revalidate changed target values; this performs no existence check or I/O.","summary":"Revalidate changed target values; this performs no existence check or I/O."},"id":"LibTmux::Model::ClientRef.clone","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> ClientTarget:D)","references":[{"end":41,"start":27,"target":"LibTmux::Client::ClientTarget"}],"returns":"ClientTarget:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"ClientTarget:D","target":"LibTmux::Client::ClientTarget"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":89,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-clone"},{"apiScope":"exported","doc":{"body":"Explicitly remove the current popup/overlay, including one left after timeout.","summary":"Explicitly remove the current popup/overlay, including one left after timeout."},"id":"LibTmux::Model::ClientRef.close-popup","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"close-popup","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.close-popup","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method close-popup(*%operation --> Result:D)","references":[{"end":43,"start":35,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close-popup","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":212,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-close-popup"},{"apiScope":"exported","doc":{"body":"Ask confirmation before one Invocation. A refusal is returned as a Result.","summary":"Ask confirmation before one Invocation. A refusal is returned as a Result."},"id":"LibTmux::Model::ClientRef.confirm-async","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"confirm-async","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.confirm-async","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"'Confirm? (y/n)'","keywordOnly":true,"name":"$prompt","optional":true,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method confirm-async(Invocation:D $command, Positive:D :$timeout-ms!,\n                         Str:D :$prompt = 'Confirm? (y/n)', *%operation --> Promise:D)","references":[{"end":33,"start":21,"target":"LibTmux::Command::Invocation"},{"end":54,"start":44,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"confirm-async","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                         Str:D :$prompt = 'Confirm? (y/n)', *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":237,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-confirm-async"},{"apiScope":"exported","doc":{"body":"Request detachment of this exact observed client. Completion is not exit proof.","summary":"Request detachment of this exact observed client. Completion is not exit proof."},"id":"LibTmux::Model::ClientRef.detach","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"detach","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.detach","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method detach(*%operation --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"detach","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":313,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-detach"},{"apiScope":"exported","doc":{"body":"Evaluate explicit FORMAT and strftime syntax in an existing pane context.","summary":"Evaluate explicit FORMAT and strftime syntax in an existing pane context."},"id":"LibTmux::Model::ClientRef.display-format","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"display-format","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.display-format","signatures":[{"params":[{"keywordOnly":false,"name":"$format","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"True","keywordOnly":true,"name":"$print","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-format(Str:D $format, PaneId:D :$pane!, Bool:D :$print = True,\n                          *%operation --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Types::PaneId"},{"end":128,"start":120,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-format","declaration":true},{"text":"(Str:D $format, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Bool:D :$print = True,\n                          *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":146,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-display-format"},{"apiScope":"exported","doc":{"body":"Display literal FORMAT/time text; tmux still interprets display styles.","summary":"Display literal FORMAT/time text; tmux still interprets display styles."},"id":"LibTmux::Model::ClientRef.display-message","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"display-message","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.display-message","signatures":[{"params":[{"keywordOnly":false,"name":"$message","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"Count","keywordOnly":true,"name":"$duration-ms","optional":true,"type":"Count"},{"default":"False","keywordOnly":true,"name":"$print","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-message(Str:D $message, PaneId:D :$pane!, Count :$duration-ms = Count,\n                           Bool:D :$print = False, *%operation --> Result:D)","references":[{"end":47,"start":39,"target":"LibTmux::Types::PaneId"},{"end":62,"start":57,"target":"LibTmux::Types::Count"},{"end":84,"start":79,"target":"LibTmux::Types::Count"},{"end":161,"start":153,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-message","declaration":true},{"text":"(Str:D $message, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$duration-ms = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":",\n                           Bool:D :$print = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":136,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-display-message"},{"apiScope":"exported","doc":{"body":"Display pane numbers, with an optional explicit tmux selection template.","summary":"Display pane numbers, with an optional explicit tmux selection template."},"id":"LibTmux::Model::ClientRef.display-panes-async","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"display-panes-async","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.display-panes-async","signatures":[{"params":[{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"Count","keywordOnly":true,"name":"$duration-ms","optional":true,"type":"Count"},{"default":"True","keywordOnly":true,"name":"$select","optional":true,"type":"Bool:D"},{"default":"CommandTemplate","keywordOnly":true,"name":"$template","optional":true,"type":"CommandTemplate"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method display-panes-async(Positive:D :$timeout-ms!, Count :$duration-ms = Count,\n                               Bool:D :$select = True,\n                               CommandTemplate :$template = CommandTemplate,\n                               *%operation --> Promise:D)","references":[{"end":37,"start":27,"target":"LibTmux::Types::Positive"},{"end":58,"start":53,"target":"LibTmux::Types::Count"},{"end":80,"start":75,"target":"LibTmux::Types::Count"},{"end":183,"start":168,"target":"LibTmux::Client::CommandTemplate"},{"end":212,"start":197,"target":"LibTmux::Client::CommandTemplate"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":26,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"display-panes-async","declaration":true},{"text":"("},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!, "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$duration-ms = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":",\n                               Bool:D :$select = True,\n                               "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":" :$template = "},{"text":"CommandTemplate","target":"LibTmux::Client::CommandTemplate"},{"text":",\n                               *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":287,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-display-panes-async"},{"apiScope":"exported","doc":{"body":"Return the registered client schema without I/O.","summary":"Return the registered client schema without I/O."},"id":"LibTmux::Model::ClientRef.entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":571,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-entity"},{"apiScope":"exported","doc":{"body":"Open the native finder using tmux match/FORMAT syntax, not literal substring data.","summary":"Open the native finder using tmux match/FORMAT syntax, not literal substring data."},"id":"LibTmux::Model::ClientRef.find-window","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"find-window","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.find-window","signatures":[{"params":[{"keywordOnly":false,"name":"$pattern","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"default":"True","keywordOnly":true,"name":"$content","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$names","optional":true,"type":"Bool:D"},{"default":"True","keywordOnly":true,"name":"$titles","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$regex","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$ignore-case","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$zoom","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method find-window(Str:D $pattern, PaneId:D :$pane!, Bool:D :$content = True,\n                       Bool:D :$names = True, Bool:D :$titles = True,\n                       Bool:D :$regex = False, Bool:D :$ignore-case = False,\n                       Bool:D :$zoom = False, *%operation --> Result:D)","references":[{"end":43,"start":35,"target":"LibTmux::Types::PaneId"},{"end":295,"start":287,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"find-window","declaration":true},{"text":"(Str:D $pattern, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, Bool:D :$content = True,\n                       Bool:D :$names = True, Bool:D :$titles = True,\n                       Bool:D :$regex = False, Bool:D :$ignore-case = False,\n                       Bool:D :$zoom = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":269,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-find-window"},{"apiScope":"exported","doc":{"body":"Acquire a fresh graph and require the observed name, process and creation time.","summary":"Acquire a fresh graph and require the observed name, process and creation time."},"id":"LibTmux::Model::ClientRef.inspect","kind":"method","modifiers":[],"name":"inspect","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.inspect","signatures":[{"params":[],"raw":"method inspect(--> Client:D)","references":[{"end":27,"start":19,"target":"LibTmux::Model::Client"}],"returns":"Client:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(--> "},{"text":"Client:D","target":"LibTmux::Model::Client"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":574,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-inspect"},{"apiScope":"exported","doc":{"body":"Select an existing key table; its name is passed without FORMAT expansion.","summary":"Select an existing key table; its name is passed without FORMAT expansion."},"id":"LibTmux::Model::ClientRef.key-table","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"key-table","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.key-table","signatures":[{"params":[{"keywordOnly":false,"name":"$table","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method key-table(Str:D $table, *%operation --> Result:D)","references":[{"end":55,"start":47,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"key-table","declaration":true},{"text":"(Str:D $table, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":337,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-key-table"},{"apiScope":"exported","doc":{"body":"Invoke the configured lock command for this client.","summary":"Invoke the configured lock command for this client."},"id":"LibTmux::Model::ClientRef.lock","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"lock","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.lock","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method lock(*%operation --> Result:D)","references":[{"end":36,"start":28,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"lock","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":323,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-lock"},{"apiScope":"exported","doc":{"body":"Show a menu. Completion follows tmux's command lifecycle, not rendering proof.","summary":"Show a menu. Completion follows tmux's command lifecycle, not rendering proof."},"id":"LibTmux::Model::ClientRef.menu-async","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"menu-async","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.menu-async","signatures":[{"params":[{"keywordOnly":false,"name":"$items","optional":false,"type":"Positional:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"''","keywordOnly":true,"name":"$title","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$x","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$y","optional":true,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$stay-open","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$mouse","optional":true,"type":"Bool:D"},{"default":"Str","keywordOnly":true,"name":"$style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$border-style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$selected-style","optional":true,"type":"Str"},{"default":"Str","keywordOnly":true,"name":"$border-lines","optional":true,"type":"Str"},{"default":"Count","keywordOnly":true,"name":"$starting-choice","optional":true,"type":"Count"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method menu-async(Positional:D $items, PaneId:D :$pane!, Positive:D :$timeout-ms!,\n                      Str:D :$title = '', Str:D :$x = 'C', Str:D :$y = 'C',\n                      Bool:D :$stay-open = False, Bool:D :$mouse = False,\n                      Str :$style = Str, Str :$border-style = Str,\n                      Str :$selected-style = Str, Str :$border-lines = Str,\n                      Count :$starting-choice = Count, *%operation --> Promise:D)","references":[{"end":47,"start":39,"target":"LibTmux::Types::PaneId"},{"end":67,"start":57,"target":"LibTmux::Types::Positive"},{"end":403,"start":398,"target":"LibTmux::Types::Count"},{"end":429,"start":424,"target":"LibTmux::Types::Count"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"menu-async","declaration":true},{"text":"(Positional:D $items, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                      Str:D :$title = '', Str:D :$x = 'C', Str:D :$y = 'C',\n                      Bool:D :$stay-open = False, Bool:D :$mouse = False,\n                      Str :$style = Str, Str :$border-style = Str,\n                      Str :$selected-style = Str, Str :$border-lines = Str,\n                      "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":" :$starting-choice = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":", *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":155,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-menu-async"},{"apiScope":"exported","doc":{"body":"Start an explicitly supplied shell command in a popup; wait asynchronously.","summary":"Start an explicitly supplied shell command in a popup; wait asynchronously."},"id":"LibTmux::Model::ClientRef.popup-async","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"popup-async","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.popup-async","signatures":[{"params":[{"keywordOnly":true,"name":"$shell-command","optional":false,"type":"Str:D"},{"keywordOnly":true,"name":"$pane","optional":false,"type":"PaneId:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"''","keywordOnly":true,"name":"$title","optional":true,"type":"Str:D"},{"default":"Str","keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"default":"Positive","keywordOnly":true,"name":"$width","optional":true,"type":"Positive"},{"default":"Positive","keywordOnly":true,"name":"$height","optional":true,"type":"Positive"},{"default":"'C'","keywordOnly":true,"name":"$x","optional":true,"type":"Str:D"},{"default":"'C'","keywordOnly":true,"name":"$y","optional":true,"type":"Str:D"},{"default":"'exit'","keywordOnly":true,"name":"$close","optional":true,"type":"Str:D"},{"default":"True","keywordOnly":true,"name":"$border","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$close-on-key","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$reset-flags","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method popup-async(Str:D :$shell-command!, PaneId:D :$pane!, Positive:D :$timeout-ms!,\n                       Str:D :$title = '', Str :$directory = Str,\n                       Positive :$width = Positive, Positive :$height = Positive,\n                       Str:D :$x = 'C', Str:D :$y = 'C',\n                       Str:D :$close = 'exit', Bool:D :$border = True,\n                       Bool:D :$close-on-key = False, Bool:D :$reset-flags = False,\n                       *%operation --> Promise:D)","references":[{"end":51,"start":43,"target":"LibTmux::Types::PaneId"},{"end":71,"start":61,"target":"LibTmux::Types::Positive"},{"end":184,"start":176,"target":"LibTmux::Types::Positive"},{"end":203,"start":195,"target":"LibTmux::Types::Positive"},{"end":213,"start":205,"target":"LibTmux::Types::Positive"},{"end":233,"start":225,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"popup-async","declaration":true},{"text":"(Str:D :$shell-command!, "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":" :$pane!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                       Str:D :$title = '', Str :$directory = Str,\n                       "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$width = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$height = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":",\n                       Str:D :$x = 'C', Str:D :$y = 'C',\n                       Str:D :$close = 'exit', Bool:D :$border = True,\n                       Bool:D :$close-on-key = False, Bool:D :$reset-flags = False,\n                       *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":188,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-popup-async"},{"apiScope":"exported","doc":{"body":"Prompt with explicit tmux template syntax. Commas separate prompts and inputs.","summary":"Prompt with explicit tmux template syntax. Commas separate prompts and inputs."},"id":"LibTmux::Model::ClientRef.prompt-async","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"prompt-async","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.prompt-async","signatures":[{"params":[{"keywordOnly":false,"name":"$template","optional":false,"type":"CommandTemplate:D"},{"keywordOnly":true,"name":"$timeout-ms","optional":false,"type":"Positive:D"},{"default":"':'","keywordOnly":true,"name":"$prompts","optional":true,"type":"Str:D"},{"default":"''","keywordOnly":true,"name":"$inputs","optional":true,"type":"Str:D"},{"default":"'text'","keywordOnly":true,"name":"$mode","optional":true,"type":"Str:D"},{"default":"'command'","keywordOnly":true,"name":"$type","optional":true,"type":"Str:D"},{"default":"False","keywordOnly":true,"name":"$literal-commas","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method prompt-async(CommandTemplate:D $template, Positive:D :$timeout-ms!,\n                        Str:D :$prompts = ':', Str:D :$inputs = '',\n                        Str:D :$mode = 'text', Str:D :$type = 'command',\n                        Bool:D :$literal-commas = False,\n                        *%operation --> Promise:D)","references":[{"end":37,"start":20,"target":"LibTmux::Client::CommandTemplate"},{"end":59,"start":49,"target":"LibTmux::Types::Positive"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"prompt-async","declaration":true},{"text":"("},{"text":"CommandTemplate:D","target":"LibTmux::Client::CommandTemplate"},{"text":" $template, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$timeout-ms!,\n                        Str:D :$prompts = ':', Str:D :$inputs = '',\n                        Str:D :$mode = 'text', Str:D :$type = 'command',\n                        Bool:D :$literal-commas = False,\n                        *%operation --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":217,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-prompt-async"},{"apiScope":"exported","doc":{"body":"Return raw prompt-history output, without claiming newline-safe entry framing.","summary":"Return raw prompt-history output, without claiming newline-safe entry framing."},"id":"LibTmux::Model::ClientRef.prompt-history","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"prompt-history","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.prompt-history","signatures":[{"params":[{"default":"Str","keywordOnly":true,"name":"$type","optional":true,"type":"Str"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method prompt-history(Str :$type = Str, *%operation --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"prompt-history","declaration":true},{"text":"(Str :$type = Str, *%operation --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":359,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-prompt-history"},{"apiScope":"exported","doc":{"body":"Refresh the display, status, or viewport using one explicit action.","summary":"Refresh the display, status, or viewport using one explicit action."},"id":"LibTmux::Model::ClientRef.refresh","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"refresh","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.refresh","signatures":[{"params":[{"default":"'all'","keywordOnly":true,"name":"$part","optional":true,"type":"Str:D"},{"default":"Positive","keywordOnly":true,"name":"$amount","optional":true,"type":"Positive"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method refresh(Str:D :$part = 'all', Positive :$amount = Positive,\n                   *%operation --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Types::Positive"},{"end":65,"start":57,"target":"LibTmux::Types::Positive"},{"end":110,"start":102,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"refresh","declaration":true},{"text":"(Str:D :$part = 'all', "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" :$amount = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":",\n                   *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":299,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-refresh"},{"apiScope":"exported","doc":{"body":"Compare captured identities without checking whether the client remains attached.","summary":"Compare captured identities without checking whether the client remains attached."},"id":"LibTmux::Model::ClientRef.same-entity","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false}],"raw":"method same-entity($other --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"($other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":587,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-same-entity"},{"apiScope":"exported","doc":{"body":"Suspend the client's terminal process through tmux.","summary":"Suspend the client's terminal process through tmux."},"id":"LibTmux::Model::ClientRef.suspend","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"suspend","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.suspend","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method suspend(*%operation --> Result:D)","references":[{"end":39,"start":31,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"suspend","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":318,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-suspend"},{"apiScope":"exported","doc":{"body":"Switch session by ID. Updating the session environment is opt-in.","summary":"Switch session by ID. Updating the session environment is opt-in."},"id":"LibTmux::Model::ClientRef.switch","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"switch","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.switch","signatures":[{"params":[{"keywordOnly":false,"name":"$session","optional":false,"type":"SessionId:D"},{"default":"False","keywordOnly":true,"name":"$update-environment","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$keep-zoom","optional":true,"type":"Bool:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method switch(SessionId:D $session, Bool:D :$update-environment = False,\n                  Bool:D :$keep-zoom = False, *%operation --> Result:D)","references":[{"end":25,"start":14,"target":"LibTmux::Types::SessionId"},{"end":143,"start":135,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"switch","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" $session, Bool:D :$update-environment = False,\n                  Bool:D :$keep-zoom = False, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":328,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-switch"},{"apiScope":"exported","doc":{"body":"Switch relative to this client's current/previous session.","summary":"Switch relative to this client's current/previous session."},"id":"LibTmux::Model::ClientRef.switch-relative","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"switch-relative","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.switch-relative","signatures":[{"params":[{"keywordOnly":false,"name":"$direction","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method switch-relative(Str:D $direction, *%operation --> Result:D)","references":[{"end":65,"start":57,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"switch-relative","declaration":true},{"text":"(Str:D $direction, *%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":344,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-switch-relative"},{"apiScope":"exported","doc":{"body":"Toggle read-only and ignore-size flags while retaining the observed session.","summary":"Toggle read-only and ignore-size flags while retaining the observed session."},"id":"LibTmux::Model::ClientRef.toggle-read-only","inheritedFrom":"LibTmux::Client::ClientTarget","kind":"method","modifiers":[],"name":"toggle-read-only","package":"LibTmux","parent":"LibTmux::Model::ClientRef","product":"core","publicId":"LibTmux::Model::ClientRef.toggle-read-only","signatures":[{"params":[{"keywordOnly":false,"name":"%operation","optional":false}],"raw":"method toggle-read-only(*%operation --> Result:D)","references":[{"end":48,"start":40,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":23,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"toggle-read-only","declaration":true},{"text":"(*%operation --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Client.rakumod","line":353,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientref-toggle-read-only"},{"apiScope":"exported","doc":{"body":"Replayable typed client membership with local filtering.","summary":"Replayable typed client membership with local filtering."},"id":"LibTmux::Model::ClientSelection","kind":"class","modifiers":[],"name":"ClientSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::ClientSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":968,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::ClientSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::ClientSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::ClientSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::ClientSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::ClientSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-list-1pg8"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::ClientSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::ClientSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::ClientSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::ClientSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::ClientSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::ClientSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::ClientSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::ClientSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::ClientSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::ClientSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::ClientSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-list-pvya"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::ClientSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::ClientSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::ClientSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::ClientSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::ClientSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::ClientSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::ClientSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::ClientSelection","product":"core","publicId":"LibTmux::Model::ClientSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-clientselection-where"},{"apiScope":"exported","doc":{"body":"Captured pane fields and its local physical-window relationship.","summary":"Captured pane fields and its local physical-window relationship."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::Pane","kind":"class","modifiers":[],"name":"Pane","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Pane","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":942,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane"},{"apiScope":"exported","doc":{"body":"Captured ` pane_active `; local bool access.","summary":"Captured ` pane_active `; local bool access."},"id":"LibTmux::Model::Pane.active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.active","signatures":[{"params":[],"raw":"method active(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"active","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":80,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-active"},{"apiScope":"exported","doc":{"body":"Captured ` pane_at_bottom `; local bool access.","summary":"Captured ` pane_at_bottom `; local bool access."},"id":"LibTmux::Model::Pane.at-bottom","kind":"method","modifiers":[],"name":"at-bottom","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.at-bottom","signatures":[{"params":[],"raw":"method at-bottom(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"at-bottom","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":136,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-at-bottom"},{"apiScope":"exported","doc":{"body":"Captured ` pane_at_left `; local bool access.","summary":"Captured ` pane_at_left `; local bool access."},"id":"LibTmux::Model::Pane.at-left","kind":"method","modifiers":[],"name":"at-left","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.at-left","signatures":[{"params":[],"raw":"method at-left(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"at-left","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":138,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-at-left"},{"apiScope":"exported","doc":{"body":"Captured ` pane_at_right `; local bool access.","summary":"Captured ` pane_at_right `; local bool access."},"id":"LibTmux::Model::Pane.at-right","kind":"method","modifiers":[],"name":"at-right","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.at-right","signatures":[{"params":[],"raw":"method at-right(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"at-right","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":140,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-at-right"},{"apiScope":"exported","doc":{"body":"Captured ` pane_at_top `; local bool access.","summary":"Captured ` pane_at_top `; local bool access."},"id":"LibTmux::Model::Pane.at-top","kind":"method","modifiers":[],"name":"at-top","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.at-top","signatures":[{"params":[],"raw":"method at-top(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"at-top","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":134,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-at-top"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::Pane.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Pane.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-clone"},{"apiScope":"exported","doc":{"body":"Captured ` pane_command_running `; local bool access.","summary":"Captured ` pane_command_running `; local bool access."},"id":"LibTmux::Model::Pane.command-running","kind":"method","modifiers":[],"name":"command-running","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.command-running","signatures":[{"params":[],"raw":"method command-running(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command-running","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":130,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-command-running"},{"apiScope":"exported","doc":{"body":"Captured ` pane_command_status `; local int access.","summary":"Captured ` pane_command_status `; local int access."},"id":"LibTmux::Model::Pane.command-status","kind":"method","modifiers":[],"name":"command-status","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.command-status","signatures":[{"params":[],"raw":"method command-status(--> Int)","references":[],"returns":"Int","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command-status","declaration":true},{"text":"(--> Int)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":132,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-command-status"},{"apiScope":"exported","doc":{"body":"Captured ` pane_current_command `; local text access.","summary":"Captured ` pane_current_command `; local text access."},"id":"LibTmux::Model::Pane.current-command","kind":"method","modifiers":[],"name":"current-command","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.current-command","signatures":[{"params":[],"raw":"method current-command(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"current-command","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":96,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-current-command"},{"apiScope":"exported","doc":{"body":"Captured ` pane_current_path `; local text access.","summary":"Captured ` pane_current_path `; local text access."},"id":"LibTmux::Model::Pane.current-path","kind":"method","modifiers":[],"name":"current-path","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.current-path","signatures":[{"params":[],"raw":"method current-path(--> Str)","references":[],"returns":"Str","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"current-path","declaration":true},{"text":"(--> Str)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":98,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-current-path"},{"apiScope":"exported","doc":{"body":"Captured ` pane_dead `; local bool access.","summary":"Captured ` pane_dead `; local bool access."},"id":"LibTmux::Model::Pane.dead","kind":"method","modifiers":[],"name":"dead","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.dead","signatures":[{"params":[],"raw":"method dead(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"dead","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":104,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-dead"},{"apiScope":"exported","doc":{"body":"Captured ` pane_dead_signal `; local text access.","summary":"Captured ` pane_dead_signal `; local text access."},"id":"LibTmux::Model::Pane.dead-signal","kind":"method","modifiers":[],"name":"dead-signal","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.dead-signal","signatures":[{"params":[],"raw":"method dead-signal(--> Str)","references":[],"returns":"Str","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"dead-signal","declaration":true},{"text":"(--> Str)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":108,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-dead-signal"},{"apiScope":"exported","doc":{"body":"Captured ` pane_dead_status `; local uint access.","summary":"Captured ` pane_dead_status `; local uint access."},"id":"LibTmux::Model::Pane.dead-status","kind":"method","modifiers":[],"name":"dead-status","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.dead-status","signatures":[{"params":[],"raw":"method dead-status(--> Count)","references":[{"end":28,"start":23,"target":"LibTmux::Types::Count"}],"returns":"Count","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"dead-status","declaration":true},{"text":"(--> "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":106,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-dead-status"},{"apiScope":"exported","doc":{"body":"Captured ` pane_dead_time `; local uint access.","summary":"Captured ` pane_dead_time `; local uint access."},"id":"LibTmux::Model::Pane.dead-time","kind":"method","modifiers":[],"name":"dead-time","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.dead-time","signatures":[{"params":[],"raw":"method dead-time(--> Count)","references":[{"end":26,"start":21,"target":"LibTmux::Types::Count"}],"returns":"Count","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"dead-time","declaration":true},{"text":"(--> "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":110,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-dead-time"},{"apiScope":"exported","doc":{"body":"Captured ` pane_floating_flag `; local bool access.","summary":"Captured ` pane_floating_flag `; local bool access."},"id":"LibTmux::Model::Pane.floating","kind":"method","modifiers":[],"name":"floating","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.floating","signatures":[{"params":[],"raw":"method floating(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"floating","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":120,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-floating"},{"apiScope":"exported","doc":{"body":"Captured ` pane_height `; local uint access.","summary":"Captured ` pane_height `; local uint access."},"id":"LibTmux::Model::Pane.height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.height","signatures":[{"params":[],"raw":"method height(--> Count:D)","references":[{"end":25,"start":18,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"height","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":84,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-height"},{"apiScope":"exported","doc":{"body":"Captured ` pane_id `; local pane-id access.","summary":"Captured ` pane_id `; local pane-id access."},"id":"LibTmux::Model::Pane.id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.id","signatures":[{"params":[],"raw":"method id(--> PaneId:D)","references":[{"end":22,"start":14,"target":"LibTmux::Types::PaneId"}],"returns":"PaneId:D","nativeSyntax":[{"start":7,"end":9,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"id","declaration":true},{"text":"(--> "},{"text":"PaneId:D","target":"LibTmux::Types::PaneId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-id"},{"apiScope":"exported","doc":{"body":"Captured ` pane_in_mode `; local uint access.","summary":"Captured ` pane_in_mode `; local uint access."},"id":"LibTmux::Model::Pane.in-mode","kind":"method","modifiers":[],"name":"in-mode","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.in-mode","signatures":[{"params":[],"raw":"method in-mode(--> Count:D)","references":[{"end":26,"start":19,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"in-mode","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":112,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-in-mode"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Pane.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` pane_index `; local uint access.","summary":"Captured ` pane_index `; local uint access."},"id":"LibTmux::Model::Pane.index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.index","signatures":[{"params":[],"raw":"method index(--> Count:D)","references":[{"end":24,"start":17,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"index","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-index"},{"apiScope":"exported","doc":{"body":"Captured ` pane_left `; local uint access.","summary":"Captured ` pane_left `; local uint access."},"id":"LibTmux::Model::Pane.left","kind":"method","modifiers":[],"name":"left","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.left","signatures":[{"params":[],"raw":"method left(--> Count:D)","references":[{"end":23,"start":16,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"left","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":86,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-left"},{"apiScope":"exported","doc":{"body":"Captured ` pane_modal_flag `; local bool access.","summary":"Captured ` pane_modal_flag `; local bool access."},"id":"LibTmux::Model::Pane.modal","kind":"method","modifiers":[],"name":"modal","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.modal","signatures":[{"params":[],"raw":"method modal(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"modal","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":122,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-modal"},{"apiScope":"exported","doc":{"body":"Captured ` pane_mode `; local text access.","summary":"Captured ` pane_mode `; local text access."},"id":"LibTmux::Model::Pane.mode","kind":"method","modifiers":[],"name":"mode","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.mode","signatures":[{"params":[],"raw":"method mode(--> Str)","references":[],"returns":"Str","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"mode","declaration":true},{"text":"(--> Str)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":114,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-mode"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::Pane.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-new"},{"apiScope":"exported","doc":{"body":"Captured ` pane_pid `; local uint access.","summary":"Captured ` pane_pid `; local uint access."},"id":"LibTmux::Model::Pane.pid","kind":"method","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.pid","signatures":[{"params":[],"raw":"method pid(--> Count)","references":[{"end":20,"start":15,"target":"LibTmux::Types::Count"}],"returns":"Count","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pid","declaration":true},{"text":"(--> "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-pid"},{"apiScope":"exported","doc":{"body":"Captured ` pane_pipe `; local bool access.","summary":"Captured ` pane_pipe `; local bool access."},"id":"LibTmux::Model::Pane.pipe","kind":"method","modifiers":[],"name":"pipe","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.pipe","signatures":[{"params":[],"raw":"method pipe(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pipe","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":116,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-pipe"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::Pane.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::Pane.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::Pane.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-same-entity"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::Pane.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-snapshot"},{"apiScope":"exported","doc":{"body":"Captured ` pane_start_command `; local text access.","summary":"Captured ` pane_start_command `; local text access."},"id":"LibTmux::Model::Pane.start-command","kind":"method","modifiers":[],"name":"start-command","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.start-command","signatures":[{"params":[],"raw":"method start-command(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"start-command","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":100,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-start-command"},{"apiScope":"exported","doc":{"body":"Captured ` pane_start_path `; local text access.","summary":"Captured ` pane_start_path `; local text access."},"id":"LibTmux::Model::Pane.start-path","kind":"method","modifiers":[],"name":"start-path","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.start-path","signatures":[{"params":[],"raw":"method start-path(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"start-path","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":102,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-start-path"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::Pane.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-state"},{"apiScope":"exported","doc":{"body":"Captured ` pane_synchronized `; local bool access.","summary":"Captured ` pane_synchronized `; local bool access."},"id":"LibTmux::Model::Pane.synchronized","kind":"method","modifiers":[],"name":"synchronized","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.synchronized","signatures":[{"params":[],"raw":"method synchronized(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"synchronized","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":118,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-synchronized"},{"apiScope":"exported","doc":{"body":"Captured ` pane_title `; local text access.","summary":"Captured ` pane_title `; local text access."},"id":"LibTmux::Model::Pane.title","kind":"method","modifiers":[],"name":"title","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.title","signatures":[{"params":[],"raw":"method title(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"title","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-title"},{"apiScope":"exported","doc":{"body":"Captured ` pane_top `; local uint access.","summary":"Captured ` pane_top `; local uint access."},"id":"LibTmux::Model::Pane.top","kind":"method","modifiers":[],"name":"top","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.top","signatures":[{"params":[],"raw":"method top(--> Count:D)","references":[{"end":22,"start":15,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"top","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-top"},{"apiScope":"exported","doc":{"body":"Captured ` pane_tty `; local text access.","summary":"Captured ` pane_tty `; local text access."},"id":"LibTmux::Model::Pane.tty","kind":"method","modifiers":[],"name":"tty","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.tty","signatures":[{"params":[],"raw":"method tty(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"tty","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":92,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-tty"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::Pane.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-value"},{"apiScope":"exported","doc":{"body":"Captured ` pane_width `; local uint access.","summary":"Captured ` pane_width `; local uint access."},"id":"LibTmux::Model::Pane.width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.width","signatures":[{"params":[],"raw":"method width(--> Count:D)","references":[{"end":24,"start":17,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"width","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":82,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-width"},{"apiScope":"exported","doc":{"body":"The observed physical window, resolved without I/O.","summary":"The observed physical window, resolved without I/O."},"id":"LibTmux::Model::Pane.window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.window","signatures":[{"params":[],"raw":"method window(--> Window:D)","references":[{"end":26,"start":18,"target":"LibTmux::Model::Window"}],"returns":"Window:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window","declaration":true},{"text":"(--> "},{"text":"Window:D","target":"LibTmux::Model::Window"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":944,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-window"},{"apiScope":"exported","doc":{"body":"Captured ` window_id `; local window-id access.","summary":"Captured ` window_id `; local window-id access."},"id":"LibTmux::Model::Pane.window-id","kind":"method","modifiers":[],"name":"window-id","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.window-id","signatures":[{"params":[],"raw":"method window-id(--> WindowId:D)","references":[{"end":31,"start":21,"target":"LibTmux::Types::WindowId"}],"returns":"WindowId:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window-id","declaration":true},{"text":"(--> "},{"text":"WindowId:D","target":"LibTmux::Types::WindowId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":76,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-window-id"},{"apiScope":"exported","doc":{"body":"Captured ` pane_x `; local int access.","summary":"Captured ` pane_x `; local int access."},"id":"LibTmux::Model::Pane.x","kind":"method","modifiers":[],"name":"x","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.x","signatures":[{"params":[],"raw":"method x(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":8,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"x","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":124,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-x"},{"apiScope":"exported","doc":{"body":"Captured ` pane_y `; local int access.","summary":"Captured ` pane_y `; local int access."},"id":"LibTmux::Model::Pane.y","kind":"method","modifiers":[],"name":"y","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.y","signatures":[{"params":[],"raw":"method y(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":8,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"y","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":126,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-y"},{"apiScope":"exported","doc":{"body":"Captured ` pane_z `; local uint access.","summary":"Captured ` pane_z `; local uint access."},"id":"LibTmux::Model::Pane.z","kind":"method","modifiers":[],"name":"z","package":"LibTmux","parent":"LibTmux::Model::Pane","product":"core","publicId":"LibTmux::Model::Pane.z","signatures":[{"params":[],"raw":"method z(--> Count:D)","references":[{"end":20,"start":13,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":8,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"z","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":128,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-pane-z"},{"apiScope":"exported","doc":{"body":"Value-only command target for a physical pane in one daemon incarnation.","summary":"Value-only command target for a physical pane in one daemon incarnation."},"id":"LibTmux::Model::PaneRef","kind":"class","modifiers":[],"name":"PaneRef","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::PaneRef","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":242,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref"},{"apiScope":"exported","doc":{"body":"Move this pane to a new window in an explicit session, returning the reported window ID.","summary":"Move this pane to a new window in an explicit session, returning the reported window ID."},"id":"LibTmux::Model::PaneRef.break","kind":"method","modifiers":[],"name":"break","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.break","signatures":[{"params":[{"keywordOnly":false,"name":"$session","optional":false,"type":"SessionRef:D"},{"default":"Count","keywordOnly":true,"name":"$index","optional":true},{"keywordOnly":true,"name":"$name","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$from","optional":true,"type":"WindowLinkRef"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"}],"raw":"method break(SessionRef:D $session, :$index = Count, Str :$name,\n                 WindowLinkRef :$from, Bool :$select = False --> WindowRef:D)","references":[{"end":25,"start":13,"target":"LibTmux::Model::SessionRef"},{"end":51,"start":46,"target":"LibTmux::Types::Count"},{"end":95,"start":82,"target":"LibTmux::Model::WindowLinkRef"},{"end":141,"start":130,"target":"LibTmux::Model::WindowRef"}],"returns":"WindowRef:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"break","declaration":true},{"text":"("},{"text":"SessionRef:D","target":"LibTmux::Model::SessionRef"},{"text":" $session, :$index = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":", Str :$name,\n                 "},{"text":"WindowLinkRef","target":"LibTmux::Model::WindowLinkRef"},{"text":" :$from, Bool :$select = False --> "},{"text":"WindowRef:D","target":"LibTmux::Model::WindowRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":406,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-break"},{"apiScope":"exported","doc":{"body":"Acquire screen/history bytes with explicit bounds and whitespace options.","summary":"Acquire screen/history bytes with explicit bounds and whitespace options."},"id":"LibTmux::Model::PaneRef.capture","kind":"method","modifiers":[],"name":"capture","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.capture","signatures":[{"params":[{"keywordOnly":true,"name":"$start","optional":true,"type":"Int"},{"keywordOnly":true,"name":"$end","optional":true,"type":"Int"},{"default":"False","keywordOnly":true,"name":"$history","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$join-wrapped","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$escape-sequences","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$escape-controls","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$alternate","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$trailing-spaces","optional":true,"type":"Bool"}],"raw":"method capture(Int :$start, Int :$end, Bool :$history = False,\n                   Bool :$join-wrapped = False, Bool :$escape-sequences = False,\n                   Bool :$escape-controls = False, Bool :$alternate = False,\n                   Bool :$trailing-spaces = False --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capture","declaration":true},{"text":"(Int :$start, Int :$end, Bool :$history = False,\n                   Bool :$join-wrapped = False, Bool :$escape-sequences = False,\n                   Bool :$escape-controls = False, Bool :$alternate = False,\n                   Bool :$trailing-spaces = False --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":257,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-capture"},{"apiScope":"exported","doc":{"body":"Acquire incomplete terminal escape input as bytes, separate from screen capture.","summary":"Acquire incomplete terminal escape input as bytes, separate from screen capture."},"id":"LibTmux::Model::PaneRef.capture-pending","kind":"method","modifiers":[],"name":"capture-pending","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.capture-pending","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$escape-controls","optional":true,"type":"Bool"}],"raw":"method capture-pending(Bool :$escape-controls = False --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capture-pending","declaration":true},{"text":"(Bool :$escape-controls = False --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":274,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-capture-pending"},{"apiScope":"exported","doc":{"body":"Discard scrollback; visible screen contents and application state are unaffected.","summary":"Discard scrollback; visible screen contents and application state are unaffected."},"id":"LibTmux::Model::PaneRef.clear-history","kind":"method","modifiers":[],"name":"clear-history","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.clear-history","signatures":[{"params":[],"raw":"method clear-history(--> Result:D)","references":[{"end":33,"start":25,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clear-history","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":465,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-clear-history"},{"apiScope":"exported","doc":{"body":"Enter tmux's clock mode for this pane.","summary":"Enter tmux's clock mode for this pane."},"id":"LibTmux::Model::PaneRef.clock-mode","kind":"method","modifiers":[],"name":"clock-mode","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.clock-mode","signatures":[{"params":[],"raw":"method clock-mode(--> Result:D)","references":[{"end":30,"start":22,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clock-mode","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":485,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-clock-mode"},{"apiScope":"exported","doc":{"body":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics.","summary":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics."},"id":"LibTmux::Model::PaneRef.command","kind":"method","modifiers":["overload","overload","overload"],"name":"command","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.command","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method command(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"(|operation)"}]},{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"Blob.new","keywordOnly":true,"name":"$stdin","optional":true,"type":"Blob:D"}],"raw":"method command(Invocation:D $command, Blob:D :$stdin = Blob.new --> Result:D)","references":[{"end":27,"start":15,"target":"LibTmux::Command::Invocation"},{"end":76,"start":68,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, Blob:D :$stdin = Blob.new --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-command"},{"apiScope":"exported","doc":{"body":"Dispatch a native copy-mode command with separate argument values.","summary":"Dispatch a native copy-mode command with separate argument values."},"id":"LibTmux::Model::PaneRef.copy-command","kind":"method","modifiers":[],"name":"copy-command","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.copy-command","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Str:D"},{"keywordOnly":false,"name":"@arguments","optional":false}],"raw":"method copy-command(Str:D $command, *@arguments --> Result:D)","references":[{"end":60,"start":52,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"copy-command","declaration":true},{"text":"(Str:D $command, *@arguments --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":481,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-copy-command"},{"apiScope":"exported","doc":{"body":"Enter copy mode, optionally paging upward or exiting when scrolling to the bottom.","summary":"Enter copy mode, optionally paging upward or exiting when scrolling to the bottom."},"id":"LibTmux::Model::PaneRef.copy-mode","kind":"method","modifiers":[],"name":"copy-mode","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.copy-mode","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$page-up","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$exit-at-bottom","optional":true,"type":"Bool"}],"raw":"method copy-mode(Bool :$page-up = False, Bool :$exit-at-bottom = False --> Result:D)","references":[{"end":83,"start":75,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"copy-mode","declaration":true},{"text":"(Bool :$page-up = False, Bool :$exit-at-bottom = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":476,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-copy-mode"},{"apiScope":"exported","doc":{"body":"Return the registered entity schema without I/O.","summary":"Return the registered entity schema without I/O."},"id":"LibTmux::Model::PaneRef.entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":71,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-entity"},{"apiScope":"exported","doc":{"body":"Convert this tile into a floating pane with explicit dimensions.","summary":"Convert this tile into a floating pane with explicit dimensions."},"id":"LibTmux::Model::PaneRef.float","kind":"method","modifiers":[],"name":"float","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.float","signatures":[{"params":[{"keywordOnly":true,"name":"$width","optional":false,"type":"Positive:D"},{"keywordOnly":true,"name":"$height","optional":false,"type":"Positive:D"},{"keywordOnly":true,"name":"$x","optional":true,"type":"Int"},{"keywordOnly":true,"name":"$y","optional":true,"type":"Int"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"}],"raw":"method float(Positive:D :$width!, Positive:D :$height!, Int :$x, Int :$y,\n                 Bool :$select = False --> Result:D)","references":[{"end":23,"start":13,"target":"LibTmux::Types::Positive"},{"end":44,"start":34,"target":"LibTmux::Types::Positive"},{"end":125,"start":117,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"float","declaration":true},{"text":"("},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$width!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$height!, Int :$x, Int :$y,\n                 Bool :$select = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":391,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-float"},{"apiScope":"exported","doc":{"body":"Construct a value-only hook facade; its reads and writes are explicit operations.","summary":"Construct a value-only hook facade; its reads and writes are explicit operations."},"id":"LibTmux::Model::PaneRef.hooks","kind":"method","modifiers":[],"name":"hooks","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.hooks","signatures":[{"params":[],"raw":"method hooks(--> Hooks:D)","references":[{"end":24,"start":17,"target":"LibTmux::Configuration::Hooks"}],"returns":"Hooks:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"hooks","declaration":true},{"text":"(--> "},{"text":"Hooks:D","target":"LibTmux::Configuration::Hooks"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":79,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-hooks"},{"apiScope":"exported","doc":{"body":"Acquire a fresh graph and require exactly one observed entity with this ID.","summary":"Acquire a fresh graph and require exactly one observed entity with this ID."},"id":"LibTmux::Model::PaneRef.inspect","kind":"method","modifiers":["overload","overload","overload"],"name":"inspect","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.inspect","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method inspect(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(|operation)"}]},{"params":[],"raw":"method inspect(--> View:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"View:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(--> "},{"text":"View:D","target":"LibTmux::Model::View"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":101,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-inspect"},{"apiScope":"exported","doc":{"body":"Move this pane into the target's split tree; its scoped ID remains unchanged.","summary":"Move this pane into the target's split tree; its scoped ID remains unchanged."},"id":"LibTmux::Model::PaneRef.join","kind":"method","modifiers":[],"name":"join","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.join","signatures":[{"params":[{"keywordOnly":false,"name":"$target","optional":false,"type":"PaneRef:D"},{"default":"False","keywordOnly":true,"name":"$horizontal","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$before","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$full","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"Positive","keywordOnly":true,"name":"$size","optional":true},{"default":"Positive","keywordOnly":true,"name":"$percent","optional":true}],"raw":"method join(PaneRef:D $target, Bool :$horizontal = False, Bool :$before = False,\n                Bool :$full = False, Bool :$select = False,\n                :$size = Positive, :$percent = Positive --> Result:D)","references":[{"end":21,"start":12,"target":"LibTmux::Model::PaneRef"},{"end":174,"start":166,"target":"LibTmux::Types::Positive"},{"end":196,"start":188,"target":"LibTmux::Types::Positive"},{"end":209,"start":201,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"join","declaration":true},{"text":"("},{"text":"PaneRef:D","target":"LibTmux::Model::PaneRef"},{"text":" $target, Bool :$horizontal = False, Bool :$before = False,\n                Bool :$full = False, Bool :$select = False,\n                :$size = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", :$percent = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":354,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-join"},{"apiScope":"exported","doc":{"body":"Destroy the addressed entity; retained observations remain unchanged.","summary":"Destroy the addressed entity; retained observations remain unchanged."},"id":"LibTmux::Model::PaneRef.kill","kind":"method","modifiers":[],"name":"kill","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.kill","signatures":[{"params":[],"raw":"method kill(--> Result:D)","references":[{"end":24,"start":16,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"kill","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":495,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-kill"},{"apiScope":"exported","doc":{"body":"Move this pane beside an explicit pane target without changing its ID.","summary":"Move this pane beside an explicit pane target without changing its ID."},"id":"LibTmux::Model::PaneRef.move","kind":"method","modifiers":[],"name":"move","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.move","signatures":[{"params":[{"keywordOnly":false,"name":"$target","optional":false,"type":"PaneRef:D"},{"default":"False","keywordOnly":true,"name":"$horizontal","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$before","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$full","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"Positive","keywordOnly":true,"name":"$size","optional":true},{"default":"Positive","keywordOnly":true,"name":"$percent","optional":true}],"raw":"method move(PaneRef:D $target, Bool :$horizontal = False, Bool :$before = False,\n                Bool :$full = False, Bool :$select = False,\n                :$size = Positive, :$percent = Positive --> Result:D)","references":[{"end":21,"start":12,"target":"LibTmux::Model::PaneRef"},{"end":174,"start":166,"target":"LibTmux::Types::Positive"},{"end":196,"start":188,"target":"LibTmux::Types::Positive"},{"end":209,"start":201,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"move","declaration":true},{"text":"("},{"text":"PaneRef:D","target":"LibTmux::Model::PaneRef"},{"text":" $target, Bool :$horizontal = False, Bool :$before = False,\n                Bool :$full = False, Bool :$select = False,\n                :$size = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", :$percent = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":360,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-move"},{"apiScope":"exported","doc":{"body":"Move a floating pane to explicit coordinates in the supported profile.","summary":"Move a floating pane to explicit coordinates in the supported profile."},"id":"LibTmux::Model::PaneRef.move-floating","kind":"method","modifiers":[],"name":"move-floating","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.move-floating","signatures":[{"params":[{"keywordOnly":true,"name":"$x","optional":true,"type":"Int"},{"keywordOnly":true,"name":"$y","optional":true,"type":"Int"}],"raw":"method move-floating(Int :$x, Int :$y --> Result:D)","references":[{"end":50,"start":42,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"move-floating","declaration":true},{"text":"(Int :$x, Int :$y --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":366,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-move-floating"},{"apiScope":"exported","doc":{"body":"Create a floating pane. Modal input ownership requires the modal capability.","summary":"Create a floating pane. Modal input ownership requires the modal capability."},"id":"LibTmux::Model::PaneRef.new-floating","kind":"method","modifiers":[],"name":"new-floating","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.new-floating","signatures":[{"params":[{"keywordOnly":true,"name":"$width","optional":false,"type":"Positive:D"},{"keywordOnly":true,"name":"$height","optional":false,"type":"Positive:D"},{"keywordOnly":true,"name":"$x","optional":true,"type":"Int"},{"keywordOnly":true,"name":"$y","optional":true,"type":"Int"},{"default":"False","keywordOnly":true,"name":"$modal","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$empty","optional":true,"type":"Bool"},{"default":"Map.new","keywordOnly":true,"name":"$environment","optional":true,"type":"Associative:D"}],"raw":"method new-floating(Positive:D :$width!, Positive:D :$height!, Int :$x, Int :$y,\n                        Bool :$modal = False, Bool :$select = False,\n                        Str :$directory, Str :$shell-command, Bool :$empty = False,\n                        Associative:D :$environment = Map.new --> PaneRef:D)","references":[{"end":30,"start":20,"target":"LibTmux::Types::Positive"},{"end":51,"start":41,"target":"LibTmux::Types::Positive"},{"end":309,"start":300,"target":"LibTmux::Model::PaneRef"}],"returns":"PaneRef:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new-floating","declaration":true},{"text":"("},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$width!, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$height!, Int :$x, Int :$y,\n                        Bool :$modal = False, Bool :$select = False,\n                        Str :$directory, Str :$shell-command, Bool :$empty = False,\n                        Associative:D :$environment = Map.new --> "},{"text":"PaneRef:D","target":"LibTmux::Model::PaneRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":298,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-new-floating"},{"apiScope":"exported","doc":{"body":"Construct a value-only option facade scoped to this captured identity.","summary":"Construct a value-only option facade scoped to this captured identity."},"id":"LibTmux::Model::PaneRef.options","kind":"method","modifiers":[],"name":"options","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.options","signatures":[{"params":[],"raw":"method options(--> Options:D)","references":[{"end":28,"start":19,"target":"LibTmux::Configuration::Options"}],"returns":"Options:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"options","declaration":true},{"text":"(--> "},{"text":"Options:D","target":"LibTmux::Configuration::Options"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-options"},{"apiScope":"exported","doc":{"body":"The pipe command deliberately uses tmux's FORMAT and strftime shell-command syntax.","summary":"The pipe command deliberately uses tmux's FORMAT and strftime shell-command syntax."},"id":"LibTmux::Model::PaneRef.pipe","kind":"method","modifiers":[],"name":"pipe","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.pipe","signatures":[{"params":[{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$input","optional":true,"type":"Bool"},{"default":"True","keywordOnly":true,"name":"$output","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$toggle","optional":true,"type":"Bool"}],"raw":"method pipe(Str :$shell-command, Bool :$input = False, Bool :$output = True,\n                Bool :$toggle = False --> Result:D)","references":[{"end":127,"start":119,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"pipe","declaration":true},{"text":"(Str :$shell-command, Bool :$input = False, Bool :$output = True,\n                Bool :$toggle = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":487,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-pipe"},{"apiScope":"exported","doc":{"body":"Reset terminal state and clear history in one tmux queue; failure can leave partial effects.","summary":"Reset terminal state and clear history in one tmux queue; failure can leave partial effects."},"id":"LibTmux::Model::PaneRef.reset","kind":"method","modifiers":[],"name":"reset","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.reset","signatures":[{"params":[],"raw":"method reset(--> Result:D)","references":[{"end":25,"start":17,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"reset","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":469,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-reset"},{"apiScope":"exported","doc":{"body":"Reset tmux's terminal state for this pane; this does not restart its process.","summary":"Reset tmux's terminal state for this pane; this does not restart its process."},"id":"LibTmux::Model::PaneRef.reset-terminal","kind":"method","modifiers":[],"name":"reset-terminal","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.reset-terminal","signatures":[{"params":[],"raw":"method reset-terminal(--> Result:D)","references":[{"end":34,"start":26,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"reset-terminal","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":467,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-reset-terminal"},{"apiScope":"exported","doc":{"body":"Set absolute dimensions or adjust one direction; these forms cannot be mixed.","summary":"Set absolute dimensions or adjust one direction; these forms cannot be mixed."},"id":"LibTmux::Model::PaneRef.resize","kind":"method","modifiers":[],"name":"resize","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.resize","signatures":[{"params":[{"default":"Positive","keywordOnly":true,"name":"$width","optional":true},{"default":"Positive","keywordOnly":true,"name":"$height","optional":true},{"keywordOnly":true,"name":"$direction","optional":true,"type":"Str"},{"default":"Positive","keywordOnly":true,"name":"$amount","optional":true}],"raw":"method resize(:$width = Positive, :$height = Positive, Str :$direction, :$amount = Positive --> Result:D)","references":[{"end":32,"start":24,"target":"LibTmux::Types::Positive"},{"end":53,"start":45,"target":"LibTmux::Types::Positive"},{"end":91,"start":83,"target":"LibTmux::Types::Positive"},{"end":104,"start":96,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"resize","declaration":true},{"text":"(:$width = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", :$height = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", Str :$direction, :$amount = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":316,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-resize"},{"apiScope":"exported","doc":{"body":"Restart the target's process; kill must be explicit when replacing a running process.","summary":"Restart the target's process; kill must be explicit when replacing a running process."},"id":"LibTmux::Model::PaneRef.respawn","kind":"method","modifiers":[],"name":"respawn","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.respawn","signatures":[{"params":[{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$kill","optional":true,"type":"Bool"},{"default":"Map.new","keywordOnly":true,"name":"$environment","optional":true,"type":"Associative:D"}],"raw":"method respawn(Str :$shell-command, Str :$directory, Bool :$kill = False,\n                   Associative:D :$environment = Map.new --> Result:D)","references":[{"end":143,"start":135,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"respawn","declaration":true},{"text":"(Str :$shell-command, Str :$directory, Bool :$kill = False,\n                   Associative:D :$environment = Map.new --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":339,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-respawn"},{"apiScope":"exported","doc":{"body":"Compare scoped identity without acquiring current state.","summary":"Compare scoped identity without acquiring current state."},"id":"LibTmux::Model::PaneRef.same-entity","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false}],"raw":"method same-entity($other --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"($other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":116,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-same-entity"},{"apiScope":"exported","doc":{"body":"Select the exact pane or verified session-relative window placement.","summary":"Select the exact pane or verified session-relative window placement."},"id":"LibTmux::Model::PaneRef.select","kind":"method","modifiers":[],"name":"select","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.select","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$preserve-zoom","optional":true,"type":"Bool"}],"raw":"method select(Bool :$preserve-zoom = False --> Result:D)","references":[{"end":55,"start":47,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"select","declaration":true},{"text":"(Bool :$preserve-zoom = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":323,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-select"},{"apiScope":"exported","doc":{"body":"Send native key names, repeating them the requested number of times.","summary":"Send native key names, repeating them the requested number of times."},"id":"LibTmux::Model::PaneRef.send-keys","kind":"method","modifiers":[],"name":"send-keys","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.send-keys","signatures":[{"params":[{"keywordOnly":false,"name":"@keys","optional":false},{"default":"1","keywordOnly":true,"name":"$repeat","optional":true,"type":"Positive:D"}],"raw":"method send-keys(*@keys, Positive:D :$repeat = 1 --> Result:D)","references":[{"end":35,"start":25,"target":"LibTmux::Types::Positive"},{"end":61,"start":53,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"send-keys","declaration":true},{"text":"(*@keys, "},{"text":"Positive:D","target":"LibTmux::Types::Positive"},{"text":" :$repeat = 1 --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":248,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-send-keys"},{"apiScope":"exported","doc":{"body":"Send the configured primary or secondary prefix key to this pane.","summary":"Send the configured primary or secondary prefix key to this pane."},"id":"LibTmux::Model::PaneRef.send-prefix","kind":"method","modifiers":[],"name":"send-prefix","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.send-prefix","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$secondary","optional":true,"type":"Bool"}],"raw":"method send-prefix(Bool :$secondary = False --> Result:D)","references":[{"end":56,"start":48,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"send-prefix","declaration":true},{"text":"(Bool :$secondary = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":253,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-send-prefix"},{"apiScope":"exported","doc":{"body":"Send literal bytes as text without appending Enter.","summary":"Send literal bytes as text without appending Enter."},"id":"LibTmux::Model::PaneRef.send-text","kind":"method","modifiers":[],"name":"send-text","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.send-text","signatures":[{"params":[{"keywordOnly":false,"name":"$text","optional":false,"type":"Str:D"}],"raw":"method send-text(Str:D $text --> Result:D)","references":[{"end":41,"start":33,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"send-text","declaration":true},{"text":"(Str:D $text --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":244,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-send-text"},{"apiScope":"exported","doc":{"body":"Enable or disable delivery of keyboard input to this pane.","summary":"Enable or disable delivery of keyboard input to this pane."},"id":"LibTmux::Model::PaneRef.set-input","kind":"method","modifiers":[],"name":"set-input","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.set-input","signatures":[{"params":[{"keywordOnly":false,"name":"$enabled","optional":false,"type":"Bool:D"}],"raw":"method set-input(Bool:D $enabled --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set-input","declaration":true},{"text":"(Bool:D $enabled --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":331,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-set-input"},{"apiScope":"exported","doc":{"body":"Set title text through one literal FORMAT expansion; tmux title rules still apply.","summary":"Set title text through one literal FORMAT expansion; tmux title rules still apply."},"id":"LibTmux::Model::PaneRef.set-title","kind":"method","modifiers":[],"name":"set-title","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.set-title","signatures":[{"params":[{"keywordOnly":false,"name":"$title","optional":false,"type":"Str:D"}],"raw":"method set-title(Str:D $title --> Result:D)","references":[{"end":42,"start":34,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set-title","declaration":true},{"text":"(Str:D $title --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":327,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-set-title"},{"apiScope":"exported","doc":{"body":"Set a floating pane's nonnegative stacking index.","summary":"Set a floating pane's nonnegative stacking index."},"id":"LibTmux::Model::PaneRef.set-z-index","kind":"method","modifiers":[],"name":"set-z-index","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.set-z-index","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false,"type":"Count:D"}],"raw":"method set-z-index(Count:D $index --> Result:D)","references":[{"end":26,"start":19,"target":"LibTmux::Types::Count"},{"end":46,"start":38,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"set-z-index","declaration":true},{"text":"("},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":" $index --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":380,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-set-z-index"},{"apiScope":"exported","doc":{"body":"Create a detached split by default, returning the reported pane ID.","summary":"Create a detached split by default, returning the reported pane ID."},"id":"LibTmux::Model::PaneRef.split","kind":"method","modifiers":[],"name":"split","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.split","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$horizontal","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$before","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$full","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$preserve-zoom","optional":true,"type":"Bool"},{"default":"Positive","keywordOnly":true,"name":"$size","optional":true},{"default":"Positive","keywordOnly":true,"name":"$percent","optional":true},{"keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$empty","optional":true,"type":"Bool"},{"default":"Map.new","keywordOnly":true,"name":"$environment","optional":true,"type":"Associative:D"}],"raw":"method split(Bool :$horizontal = False, Bool :$before = False,\n                 Bool :$full = False, Bool :$select = False, Bool :$preserve-zoom = False,\n                 :$size = Positive, :$percent = Positive, Str :$directory,\n                 Str :$shell-command, Bool :$empty = False,\n                 Associative:D :$environment = Map.new --> PaneRef:D)","references":[{"end":188,"start":180,"target":"LibTmux::Types::Positive"},{"end":210,"start":202,"target":"LibTmux::Types::Positive"},{"end":357,"start":348,"target":"LibTmux::Model::PaneRef"}],"returns":"PaneRef:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"split","declaration":true},{"text":"(Bool :$horizontal = False, Bool :$before = False,\n                 Bool :$full = False, Bool :$select = False, Bool :$preserve-zoom = False,\n                 :$size = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", :$percent = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", Str :$directory,\n                 Str :$shell-command, Bool :$empty = False,\n                 Associative:D :$environment = Map.new --> "},{"text":"PaneRef:D","target":"LibTmux::Model::PaneRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":279,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-split"},{"apiScope":"exported","doc":{"body":"Change a floating pane's relative stacking order using a closed placement name.","summary":"Change a floating pane's relative stacking order using a closed placement name."},"id":"LibTmux::Model::PaneRef.stack","kind":"method","modifiers":[],"name":"stack","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.stack","signatures":[{"params":[{"keywordOnly":false,"name":"$placement","optional":false,"type":"Str:D"}],"raw":"method stack(Str:D $placement --> Result:D)","references":[{"end":42,"start":34,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"stack","declaration":true},{"text":"(Str:D $placement --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":373,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-stack"},{"apiScope":"exported","doc":{"body":"Swap the two verified pane identities or session-relative window placements.","summary":"Swap the two verified pane identities or session-relative window placements."},"id":"LibTmux::Model::PaneRef.swap","kind":"method","modifiers":[],"name":"swap","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.swap","signatures":[{"params":[{"keywordOnly":false,"name":"$target","optional":false,"type":"PaneRef:D"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$preserve-zoom","optional":true,"type":"Bool"}],"raw":"method swap(PaneRef:D $target, Bool :$select = False, Bool :$preserve-zoom = False --> Result:D)","references":[{"end":21,"start":12,"target":"LibTmux::Model::PaneRef"},{"end":95,"start":87,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"swap","declaration":true},{"text":"("},{"text":"PaneRef:D","target":"LibTmux::Model::PaneRef"},{"text":" $target, Bool :$select = False, Bool :$preserve-zoom = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":399,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-swap"},{"apiScope":"exported","doc":{"body":"Convert this floating pane into a tile while preserving its ID.","summary":"Convert this floating pane into a tile while preserving its ID."},"id":"LibTmux::Model::PaneRef.tile","kind":"method","modifiers":[],"name":"tile","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.tile","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"}],"raw":"method tile(Bool :$select = False --> Result:D)","references":[{"end":46,"start":38,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"tile","declaration":true},{"text":"(Bool :$select = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":385,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-tile"},{"apiScope":"exported","doc":{"body":"Toggle the global marked-pane target using this pane.","summary":"Toggle the global marked-pane target using this pane."},"id":"LibTmux::Model::PaneRef.toggle-mark","kind":"method","modifiers":[],"name":"toggle-mark","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.toggle-mark","signatures":[{"params":[],"raw":"method toggle-mark(--> Result:D)","references":[{"end":31,"start":23,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"toggle-mark","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":335,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-toggle-mark"},{"apiScope":"exported","doc":{"body":"Toggle this pane's window zoom state.","summary":"Toggle this pane's window zoom state."},"id":"LibTmux::Model::PaneRef.toggle-zoom","kind":"method","modifiers":[],"name":"toggle-zoom","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.toggle-zoom","signatures":[{"params":[],"raw":"method toggle-zoom(--> Result:D)","references":[{"end":31,"start":23,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"toggle-zoom","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":321,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-toggle-zoom"},{"apiScope":"exported","doc":{"body":"Clear the server's marked pane.","summary":"Clear the server's marked pane."},"id":"LibTmux::Model::PaneRef.unmark","kind":"method","modifiers":[],"name":"unmark","package":"LibTmux","parent":"LibTmux::Model::PaneRef","product":"core","publicId":"LibTmux::Model::PaneRef.unmark","signatures":[{"params":[],"raw":"method unmark(--> Result:D)","references":[{"end":26,"start":18,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unmark","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":337,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneref-unmark"},{"apiScope":"exported","doc":{"body":"Replayable typed pane membership with local filtering.","summary":"Replayable typed pane membership with local filtering."},"id":"LibTmux::Model::PaneSelection","kind":"class","modifiers":[],"name":"PaneSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::PaneSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":966,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::PaneSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::PaneSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::PaneSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::PaneSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::PaneSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-list-11q6"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::PaneSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::PaneSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::PaneSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::PaneSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::PaneSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::PaneSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::PaneSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::PaneSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::PaneSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::PaneSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::PaneSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-list-25wl"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::PaneSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::PaneSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::PaneSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::PaneSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::PaneSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::PaneSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::PaneSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::PaneSelection","product":"core","publicId":"LibTmux::Model::PaneSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-paneselection-where"},{"apiScope":"exported","doc":{"body":"Captured session with local window-link and group relationships.","summary":"Captured session with local window-link and group relationships."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::Session","kind":"class","modifiers":[],"name":"Session","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Session","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":910,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session"},{"apiScope":"exported","doc":{"body":"Captured ` session_activity `; local uint access.","summary":"Captured ` session_activity `; local uint access."},"id":"LibTmux::Model::Session.activity","kind":"method","modifiers":[],"name":"activity","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.activity","signatures":[{"params":[],"raw":"method activity(--> Count:D)","references":[{"end":27,"start":20,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"activity","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-activity"},{"apiScope":"exported","doc":{"body":"Captured ` session_attached `; local uint access.","summary":"Captured ` session_attached `; local uint access."},"id":"LibTmux::Model::Session.attached-count","kind":"method","modifiers":[],"name":"attached-count","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.attached-count","signatures":[{"params":[],"raw":"method attached-count(--> Count:D)","references":[{"end":33,"start":26,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"attached-count","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-attached-count"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::Session.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Session.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-clone"},{"apiScope":"exported","doc":{"body":"Captured ` session_created `; local uint access.","summary":"Captured ` session_created `; local uint access."},"id":"LibTmux::Model::Session.created","kind":"method","modifiers":[],"name":"created","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.created","signatures":[{"params":[],"raw":"method created(--> Count:D)","references":[{"end":26,"start":19,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"created","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-created"},{"apiScope":"exported","doc":{"body":"The session-relative active window placement in this observation.","summary":"The session-relative active window placement in this observation."},"id":"LibTmux::Model::Session.current-link","kind":"method","modifiers":[],"name":"current-link","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.current-link","signatures":[{"params":[],"raw":"method current-link(--> WindowLink:D)","references":[{"end":36,"start":24,"target":"LibTmux::Model::WindowLink"}],"returns":"WindowLink:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"current-link","declaration":true},{"text":"(--> "},{"text":"WindowLink:D","target":"LibTmux::Model::WindowLink"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":914,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-current-link"},{"apiScope":"exported","doc":{"body":"Observed session group, or Nil when the session is known to be ungrouped.","summary":"Observed session group, or Nil when the session is known to be ungrouped."},"id":"LibTmux::Model::Session.group","kind":"method","modifiers":[],"name":"group","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.group","signatures":[{"params":[],"raw":"method group(--> SessionGroup)","references":[{"end":29,"start":17,"target":"LibTmux::Model::SessionGroup"}],"returns":"SessionGroup","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"group","declaration":true},{"text":"(--> "},{"text":"SessionGroup","target":"LibTmux::Model::SessionGroup"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":916,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-group"},{"apiScope":"exported","doc":{"body":"Captured ` session_group `; local text access.","summary":"Captured ` session_group `; local text access."},"id":"LibTmux::Model::Session.group-name","kind":"method","modifiers":[],"name":"group-name","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.group-name","signatures":[{"params":[],"raw":"method group-name(--> Str)","references":[],"returns":"Str","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"group-name","declaration":true},{"text":"(--> Str)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-group-name"},{"apiScope":"exported","doc":{"body":"Captured ` session_grouped `; local bool access.","summary":"Captured ` session_grouped `; local bool access."},"id":"LibTmux::Model::Session.grouped","kind":"method","modifiers":[],"name":"grouped","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.grouped","signatures":[{"params":[],"raw":"method grouped(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grouped","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-grouped"},{"apiScope":"exported","doc":{"body":"Captured ` session_id `; local session-id access.","summary":"Captured ` session_id `; local session-id access."},"id":"LibTmux::Model::Session.id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.id","signatures":[{"params":[],"raw":"method id(--> SessionId:D)","references":[{"end":25,"start":14,"target":"LibTmux::Types::SessionId"}],"returns":"SessionId:D","nativeSyntax":[{"start":7,"end":9,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"id","declaration":true},{"text":"(--> "},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":11,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-id"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Session.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` session_name `; local text access.","summary":"Captured ` session_name `; local text access."},"id":"LibTmux::Model::Session.name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.name","signatures":[{"params":[],"raw":"method name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":13,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-name"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::Session.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-new"},{"apiScope":"exported","doc":{"body":"Captured ` session_path `; local text access.","summary":"Captured ` session_path `; local text access."},"id":"LibTmux::Model::Session.path","kind":"method","modifiers":[],"name":"path","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.path","signatures":[{"params":[],"raw":"method path(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"path","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":23,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-path"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::Session.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::Session.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::Session.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-same-entity"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::Session.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::Session.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::Session.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-value"},{"apiScope":"exported","doc":{"body":"Captured session/index associations, including repeated links to one physical window.","summary":"Captured session/index associations, including repeated links to one physical window."},"id":"LibTmux::Model::Session.window-links","kind":"method","modifiers":[],"name":"window-links","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.window-links","signatures":[{"params":[],"raw":"method window-links(--> WindowLinkSelection:D)","references":[{"end":45,"start":24,"target":"LibTmux::Model::WindowLinkSelection"}],"returns":"WindowLinkSelection:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window-links","declaration":true},{"text":"(--> "},{"text":"WindowLinkSelection:D","target":"LibTmux::Model::WindowLinkSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":912,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-window-links"},{"apiScope":"exported","doc":{"body":"Captured ` session_windows `; local uint access.","summary":"Captured ` session_windows `; local uint access."},"id":"LibTmux::Model::Session.windows-count","kind":"method","modifiers":[],"name":"windows-count","package":"LibTmux","parent":"LibTmux::Model::Session","product":"core","publicId":"LibTmux::Model::Session.windows-count","signatures":[{"params":[],"raw":"method windows-count(--> Count:D)","references":[{"end":32,"start":25,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"windows-count","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":15,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-session-windows-count"},{"apiScope":"exported","doc":{"body":"Captured session group whose members are resolved within this graph.","summary":"Captured session group whose members are resolved within this graph."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::SessionGroup","kind":"class","modifiers":[],"name":"SessionGroup","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::SessionGroup","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":952,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup"},{"apiScope":"exported","doc":{"body":"Captured ` session_group_attached `; local uint access.","summary":"Captured ` session_group_attached `; local uint access."},"id":"LibTmux::Model::SessionGroup.attached-count","kind":"method","modifiers":[],"name":"attached-count","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.attached-count","signatures":[{"params":[],"raw":"method attached-count(--> Count:D)","references":[{"end":33,"start":26,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"attached-count","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":178,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-attached-count"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::SessionGroup.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::SessionGroup.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-clone"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::SessionGroup.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` session_group `; local text access.","summary":"Captured ` session_group `; local text access."},"id":"LibTmux::Model::SessionGroup.name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.name","signatures":[{"params":[],"raw":"method name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":174,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-name"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::SessionGroup.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-new"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::SessionGroup.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::SessionGroup.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::SessionGroup.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-same-entity"},{"apiScope":"exported","doc":{"body":"Captured sessions in acquisition order; reading performs no I/O.","summary":"Captured sessions in acquisition order; reading performs no I/O."},"id":"LibTmux::Model::SessionGroup.sessions","kind":"method","modifiers":[],"name":"sessions","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.sessions","signatures":[{"params":[],"raw":"method sessions(--> SessionSelection:D)","references":[{"end":38,"start":20,"target":"LibTmux::Model::SessionSelection"}],"returns":"SessionSelection:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sessions","declaration":true},{"text":"(--> "},{"text":"SessionSelection:D","target":"LibTmux::Model::SessionSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":954,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-sessions"},{"apiScope":"exported","doc":{"body":"Captured ` session_group_size `; local uint access.","summary":"Captured ` session_group_size `; local uint access."},"id":"LibTmux::Model::SessionGroup.size","kind":"method","modifiers":[],"name":"size","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.size","signatures":[{"params":[],"raw":"method size(--> Count:D)","references":[{"end":23,"start":16,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"size","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":176,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-size"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::SessionGroup.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::SessionGroup.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::SessionGroup.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::SessionGroup","product":"core","publicId":"LibTmux::Model::SessionGroup.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroup-value"},{"apiScope":"exported","doc":{"body":"Replayable typed sessiongroup membership with local filtering.","summary":"Replayable typed sessiongroup membership with local filtering."},"id":"LibTmux::Model::SessionGroupSelection","kind":"class","modifiers":[],"name":"SessionGroupSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::SessionGroupSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":970,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::SessionGroupSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::SessionGroupSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::SessionGroupSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::SessionGroupSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::SessionGroupSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-list-w4pk"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::SessionGroupSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::SessionGroupSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::SessionGroupSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::SessionGroupSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::SessionGroupSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::SessionGroupSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::SessionGroupSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::SessionGroupSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::SessionGroupSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::SessionGroupSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::SessionGroupSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-list-1voz"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::SessionGroupSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::SessionGroupSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::SessionGroupSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::SessionGroupSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::SessionGroupSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::SessionGroupSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::SessionGroupSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::SessionGroupSelection","product":"core","publicId":"LibTmux::Model::SessionGroupSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessiongroupselection-where"},{"apiScope":"exported","doc":{"body":"Value-only command target for a session in one daemon incarnation.","summary":"Value-only command target for a session in one daemon incarnation."},"id":"LibTmux::Model::SessionRef","kind":"class","modifiers":[],"name":"SessionRef","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::SessionRef","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":123,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref"},{"apiScope":"exported","doc":{"body":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics.","summary":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics."},"id":"LibTmux::Model::SessionRef.command","kind":"method","modifiers":["overload","overload","overload"],"name":"command","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.command","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method command(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"(|operation)"}]},{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"Blob.new","keywordOnly":true,"name":"$stdin","optional":true,"type":"Blob:D"}],"raw":"method command(Invocation:D $command, Blob:D :$stdin = Blob.new --> Result:D)","references":[{"end":27,"start":15,"target":"LibTmux::Command::Invocation"},{"end":76,"start":68,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, Blob:D :$stdin = Blob.new --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-command"},{"apiScope":"exported","doc":{"body":"Request detachment of clients in this session; acknowledgement is not client exit.","summary":"Request detachment of clients in this session; acknowledgement is not client exit."},"id":"LibTmux::Model::SessionRef.detach-clients","kind":"method","modifiers":[],"name":"detach-clients","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.detach-clients","signatures":[{"params":[],"raw":"method detach-clients(--> Result:D)","references":[{"end":34,"start":26,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"detach-clients","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":167,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-detach-clients"},{"apiScope":"exported","doc":{"body":"Return the registered entity schema without I/O.","summary":"Return the registered entity schema without I/O."},"id":"LibTmux::Model::SessionRef.entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":71,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-entity"},{"apiScope":"exported","doc":{"body":"Construct a session environment facade without acquiring current values.","summary":"Construct a session environment facade without acquiring current values."},"id":"LibTmux::Model::SessionRef.environment","kind":"method","modifiers":[],"name":"environment","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.environment","signatures":[{"params":[],"raw":"method environment(--> Environment:D)","references":[{"end":36,"start":23,"target":"LibTmux::Configuration::Environment"}],"returns":"Environment:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"environment","declaration":true},{"text":"(--> "},{"text":"Environment:D","target":"LibTmux::Configuration::Environment"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":125,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-environment"},{"apiScope":"exported","doc":{"body":"Construct a value-only hook facade; its reads and writes are explicit operations.","summary":"Construct a value-only hook facade; its reads and writes are explicit operations."},"id":"LibTmux::Model::SessionRef.hooks","kind":"method","modifiers":[],"name":"hooks","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.hooks","signatures":[{"params":[],"raw":"method hooks(--> Hooks:D)","references":[{"end":24,"start":17,"target":"LibTmux::Configuration::Hooks"}],"returns":"Hooks:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"hooks","declaration":true},{"text":"(--> "},{"text":"Hooks:D","target":"LibTmux::Configuration::Hooks"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":79,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-hooks"},{"apiScope":"exported","doc":{"body":"Acquire a fresh graph and require exactly one observed entity with this ID.","summary":"Acquire a fresh graph and require exactly one observed entity with this ID."},"id":"LibTmux::Model::SessionRef.inspect","kind":"method","modifiers":["overload","overload","overload"],"name":"inspect","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.inspect","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method inspect(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(|operation)"}]},{"params":[],"raw":"method inspect(--> View:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"View:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(--> "},{"text":"View:D","target":"LibTmux::Model::View"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":101,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-inspect"},{"apiScope":"exported","doc":{"body":"Destroy the addressed entity; retained observations remain unchanged.","summary":"Destroy the addressed entity; retained observations remain unchanged."},"id":"LibTmux::Model::SessionRef.kill","kind":"method","modifiers":[],"name":"kill","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.kill","signatures":[{"params":[],"raw":"method kill(--> Result:D)","references":[{"end":24,"start":16,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"kill","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":169,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-kill"},{"apiScope":"exported","doc":{"body":"Select the session's previous current window.","summary":"Select the session's previous current window."},"id":"LibTmux::Model::SessionRef.last-window","kind":"method","modifiers":[],"name":"last-window","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.last-window","signatures":[{"params":[],"raw":"method last-window(--> Result:D)","references":[{"end":31,"start":23,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"last-window","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":161,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-last-window"},{"apiScope":"exported","doc":{"body":"Ask tmux to lock clients attached to this session.","summary":"Ask tmux to lock clients attached to this session."},"id":"LibTmux::Model::SessionRef.lock","kind":"method","modifiers":[],"name":"lock","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.lock","signatures":[{"params":[],"raw":"method lock(--> Result:D)","references":[{"end":24,"start":16,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"lock","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":165,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-lock"},{"apiScope":"exported","doc":{"body":"Create a window and return its reported identity without refreshing observations.","summary":"Create a window and return its reported identity without refreshing observations."},"id":"LibTmux::Model::SessionRef.new-window","kind":"method","modifiers":[],"name":"new-window","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.new-window","signatures":[{"params":[{"keywordOnly":true,"name":"$name","optional":true,"type":"Str"},{"default":"Count","keywordOnly":true,"name":"$index","optional":true},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$replace","optional":true,"type":"Bool"},{"keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$empty","optional":true,"type":"Bool"},{"default":"Map.new","keywordOnly":true,"name":"$environment","optional":true,"type":"Associative:D"}],"raw":"method new-window(Str :$name, :$index = Count, Bool :$select = False,\n                      Bool :$replace = False, Str :$directory, Str :$shell-command,\n                      Bool :$empty = False, Associative:D :$environment = Map.new --> WindowRef:D)","references":[{"end":45,"start":40,"target":"LibTmux::Types::Count"},{"end":251,"start":240,"target":"LibTmux::Model::WindowRef"}],"returns":"WindowRef:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new-window","declaration":true},{"text":"(Str :$name, :$index = "},{"text":"Count","target":"LibTmux::Types::Count"},{"text":", Bool :$select = False,\n                      Bool :$replace = False, Str :$directory, Str :$shell-command,\n                      Bool :$empty = False, Associative:D :$environment = Map.new --> "},{"text":"WindowRef:D","target":"LibTmux::Model::WindowRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":135,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-new-window"},{"apiScope":"exported","doc":{"body":"Select the next session window, optionally restricting to activity alerts.","summary":"Select the next session window, optionally restricting to activity alerts."},"id":"LibTmux::Model::SessionRef.next-window","kind":"method","modifiers":[],"name":"next-window","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.next-window","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$activity","optional":true,"type":"Bool"}],"raw":"method next-window(Bool :$activity = False --> Result:D)","references":[{"end":55,"start":47,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"next-window","declaration":true},{"text":"(Bool :$activity = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":153,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-next-window"},{"apiScope":"exported","doc":{"body":"Construct a value-only option facade scoped to this captured identity.","summary":"Construct a value-only option facade scoped to this captured identity."},"id":"LibTmux::Model::SessionRef.options","kind":"method","modifiers":[],"name":"options","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.options","signatures":[{"params":[],"raw":"method options(--> Options:D)","references":[{"end":28,"start":19,"target":"LibTmux::Configuration::Options"}],"returns":"Options:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"options","declaration":true},{"text":"(--> "},{"text":"Options:D","target":"LibTmux::Configuration::Options"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-options"},{"apiScope":"exported","doc":{"body":"Select the previous session window, optionally restricting to activity alerts.","summary":"Select the previous session window, optionally restricting to activity alerts."},"id":"LibTmux::Model::SessionRef.previous-window","kind":"method","modifiers":[],"name":"previous-window","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.previous-window","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$activity","optional":true,"type":"Bool"}],"raw":"method previous-window(Bool :$activity = False --> Result:D)","references":[{"end":59,"start":51,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"previous-window","declaration":true},{"text":"(Bool :$activity = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":157,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-previous-window"},{"apiScope":"exported","doc":{"body":"Store the exact name; refuse characters or separators the daemon would change.","summary":"Store the exact name; refuse characters or separators the daemon would change."},"id":"LibTmux::Model::SessionRef.rename","kind":"method","modifiers":[],"name":"rename","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.rename","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method rename(Str:D $name --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"rename","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":130,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-rename"},{"apiScope":"exported","doc":{"body":"Renumber this session's links; previously captured indices may become stale.","summary":"Renumber this session's links; previously captured indices may become stale."},"id":"LibTmux::Model::SessionRef.renumber-windows","kind":"method","modifiers":[],"name":"renumber-windows","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.renumber-windows","signatures":[{"params":[],"raw":"method renumber-windows(--> Result:D)","references":[{"end":36,"start":28,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":23,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"renumber-windows","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":163,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-renumber-windows"},{"apiScope":"exported","doc":{"body":"Compare scoped identity without acquiring current state.","summary":"Compare scoped identity without acquiring current state."},"id":"LibTmux::Model::SessionRef.same-entity","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::SessionRef","product":"core","publicId":"LibTmux::Model::SessionRef.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false}],"raw":"method same-entity($other --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"($other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":116,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionref-same-entity"},{"apiScope":"exported","doc":{"body":"Replayable typed session membership with local filtering.","summary":"Replayable typed session membership with local filtering."},"id":"LibTmux::Model::SessionSelection","kind":"class","modifiers":[],"name":"SessionSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::SessionSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":960,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::SessionSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::SessionSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::SessionSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::SessionSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::SessionSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-list-1wm9"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::SessionSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::SessionSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::SessionSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::SessionSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::SessionSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::SessionSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::SessionSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::SessionSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::SessionSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::SessionSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::SessionSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-list-x1z2"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::SessionSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::SessionSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::SessionSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::SessionSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::SessionSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::SessionSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::SessionSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::SessionSelection","product":"core","publicId":"LibTmux::Model::SessionSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-sessionselection-where"},{"apiScope":"exported","doc":{"body":"Captured records and indexed relations; it retains no transport or live owner.","summary":"Captured records and indexed relations; it retains no transport or live owner."},"id":"LibTmux::Model::Snapshot","kind":"class","modifiers":[],"name":"Snapshot","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Snapshot","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":595,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot"},{"apiScope":"exported","doc":{"body":"Captured buffer metadata; content requires a separate explicit operation.","summary":"Captured buffer metadata; content requires a separate explicit operation."},"id":"LibTmux::Model::Snapshot.buffers","kind":"method","modifiers":[],"name":"buffers","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.buffers","signatures":[{"params":[],"raw":"method buffers(--> BufferSelection:D)","references":[{"end":36,"start":19,"target":"LibTmux::Model::BufferSelection"}],"returns":"BufferSelection:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"buffers","declaration":true},{"text":"(--> "},{"text":"BufferSelection:D","target":"LibTmux::Model::BufferSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":691,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-buffers"},{"apiScope":"exported","doc":{"body":"Return the immutable capability observation used to acquire this graph.","summary":"Return the immutable capability observation used to acquire this graph."},"id":"LibTmux::Model::Snapshot.capabilities","kind":"method","modifiers":[],"name":"capabilities","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.capabilities","signatures":[{"params":[],"raw":"method capabilities(--> LibTmux::Capabilities:D)","references":[{"end":47,"start":24,"target":"LibTmux::Capabilities"}],"returns":"LibTmux::Capabilities:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capabilities","declaration":true},{"text":"(--> "},{"text":"LibTmux::Capabilities:D","target":"LibTmux::Capabilities"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":662,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-capabilities"},{"apiScope":"exported","doc":{"body":"Captured attached clients with their observed process and creation identity.","summary":"Captured attached clients with their observed process and creation identity."},"id":"LibTmux::Model::Snapshot.clients","kind":"method","modifiers":[],"name":"clients","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.clients","signatures":[{"params":[],"raw":"method clients(--> ClientSelection:D)","references":[{"end":36,"start":19,"target":"LibTmux::Model::ClientSelection"}],"returns":"ClientSelection:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clients","declaration":true},{"text":"(--> "},{"text":"ClientSelection:D","target":"LibTmux::Model::ClientSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":687,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-clients"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Snapshot.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":805,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-clone"},{"apiScope":"exported","doc":{"body":"Whether the named entity collection was acquired without source restriction.","summary":"Whether the named entity collection was acquired without source restriction."},"id":"LibTmux::Model::Snapshot.complete","kind":"method","modifiers":[],"name":"complete","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.complete","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method complete(Str:D $entity --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"complete","declaration":true},{"text":"(Str:D $entity --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":664,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-complete"},{"apiScope":"exported","doc":{"body":"End of the acquisition interval after declared records were captured.","summary":"End of the acquisition interval after declared records were captured."},"id":"LibTmux::Model::Snapshot.ended","kind":"property","modifiers":[],"name":"ended","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.ended","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":604,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-model-snapshot-ended"},{"apiScope":"exported","doc":{"body":"Captured connection settings; retaining them owns no process.","summary":"Captured connection settings; retaining them owns no process."},"id":"LibTmux::Model::Snapshot.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":598,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-model-snapshot-endpoint"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Snapshot.incarnation","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":660,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-incarnation"},{"apiScope":"exported","doc":{"body":"Immutable daemon identity and capabilities used during acquisition.","summary":"Immutable daemon identity and capabilities used during acquisition."},"id":"LibTmux::Model::Snapshot.observation","kind":"property","modifiers":[],"name":"observation","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.observation","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":600,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Observation:D","slug":"libtmux-model-snapshot-observation"},{"apiScope":"exported","doc":{"body":"Captured physical panes; relation traversal never acquires newer data.","summary":"Captured physical panes; relation traversal never acquires newer data."},"id":"LibTmux::Model::Snapshot.panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.panes","signatures":[{"params":[],"raw":"method panes(--> PaneSelection:D)","references":[{"end":32,"start":17,"target":"LibTmux::Model::PaneSelection"}],"returns":"PaneSelection:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"panes","declaration":true},{"text":"(--> "},{"text":"PaneSelection:D","target":"LibTmux::Model::PaneSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":685,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-panes"},{"apiScope":"exported","doc":{"body":"Return raw contextual rows, retaining repeated physical-entity observations.","summary":"Return raw contextual rows, retaining repeated physical-entity observations."},"id":"LibTmux::Model::Snapshot.rows","kind":"method","modifiers":[],"name":"rows","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.rows","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method rows(Str:D $entity --> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"rows","declaration":true},{"text":"(Str:D $entity --> List:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":667,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-rows"},{"apiScope":"exported","doc":{"body":"Return the captured typed selection for a validated entity schema.","summary":"Return the captured typed selection for a validated entity schema."},"id":"LibTmux::Model::Snapshot.selection","kind":"method","modifiers":[],"name":"selection","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.selection","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Str:D"}],"raw":"method selection(Str:D $entity)","references":[],"nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"selection","declaration":true},{"text":"(Str:D $entity)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":673,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-selection"},{"apiScope":"exported","doc":{"body":"Captured session groups and their observed membership.","summary":"Captured session groups and their observed membership."},"id":"LibTmux::Model::Snapshot.session-groups","kind":"method","modifiers":[],"name":"session-groups","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.session-groups","signatures":[{"params":[],"raw":"method session-groups(--> SessionGroupSelection:D)","references":[{"end":49,"start":26,"target":"LibTmux::Model::SessionGroupSelection"}],"returns":"SessionGroupSelection:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session-groups","declaration":true},{"text":"(--> "},{"text":"SessionGroupSelection:D","target":"LibTmux::Model::SessionGroupSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":689,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-session-groups"},{"apiScope":"exported","doc":{"body":"Captured sessions in acquisition order; reading performs no I/O.","summary":"Captured sessions in acquisition order; reading performs no I/O."},"id":"LibTmux::Model::Snapshot.sessions","kind":"method","modifiers":[],"name":"sessions","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.sessions","signatures":[{"params":[],"raw":"method sessions(--> SessionSelection:D)","references":[{"end":38,"start":20,"target":"LibTmux::Model::SessionSelection"}],"returns":"SessionSelection:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sessions","declaration":true},{"text":"(--> "},{"text":"SessionSelection:D","target":"LibTmux::Model::SessionSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":679,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-sessions"},{"apiScope":"exported","doc":{"body":"Start of the acquisition interval; the graph is not an atomic instant.","summary":"Start of the acquisition interval; the graph is not an atomic instant."},"id":"LibTmux::Model::Snapshot.started","kind":"property","modifiers":[],"name":"started","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.started","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":602,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Instant:D","slug":"libtmux-model-snapshot-started"},{"apiScope":"exported","doc":{"body":"Captured session/index associations, including repeated links to one physical window.","summary":"Captured session/index associations, including repeated links to one physical window."},"id":"LibTmux::Model::Snapshot.window-links","kind":"method","modifiers":[],"name":"window-links","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.window-links","signatures":[{"params":[],"raw":"method window-links(--> WindowLinkSelection:D)","references":[{"end":45,"start":24,"target":"LibTmux::Model::WindowLinkSelection"}],"returns":"WindowLinkSelection:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window-links","declaration":true},{"text":"(--> "},{"text":"WindowLinkSelection:D","target":"LibTmux::Model::WindowLinkSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":681,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-window-links"},{"apiScope":"exported","doc":{"body":"Captured physical windows, unique by daemon-scoped identity.","summary":"Captured physical windows, unique by daemon-scoped identity."},"id":"LibTmux::Model::Snapshot.windows","kind":"method","modifiers":[],"name":"windows","package":"LibTmux","parent":"LibTmux::Model::Snapshot","product":"core","publicId":"LibTmux::Model::Snapshot.windows","signatures":[{"params":[],"raw":"method windows(--> WindowSelection:D)","references":[{"end":36,"start":19,"target":"LibTmux::Model::WindowSelection"}],"returns":"WindowSelection:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"windows","declaration":true},{"text":"(--> "},{"text":"WindowSelection:D","target":"LibTmux::Model::WindowSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":683,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-snapshot-windows"},{"apiScope":"exported","doc":{"body":"A local view of one captured record. Accessors and relations never perform I/O.","summary":"A local view of one captured record. Accessors and relations never perform I/O."},"id":"LibTmux::Model::View","kind":"class","modifiers":[],"name":"View","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::View","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":814,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::View.bytes","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::View.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-clone"},{"apiScope":"exported","doc":{"body":"Catalogue entity schema for this view or reference.","summary":"Catalogue entity schema for this view or reference."},"id":"LibTmux::Model::View.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.entity","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":818,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-model-view-entity"},{"apiScope":"exported","doc":{"body":"Snapshot lookup key; window-link keys are not stable across captures.","summary":"Snapshot lookup key; window-link keys are not stable across captures."},"id":"LibTmux::Model::View.identity-key","kind":"property","modifiers":[],"name":"identity-key","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.identity-key","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":820,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-model-view-identity-key"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::View.incarnation","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-incarnation"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::View.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-new"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::View.ref","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::View.relation","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::View.same-entity","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-same-entity"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::View.snapshot","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::View.state","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::View.value","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::View","product":"core","publicId":"LibTmux::Model::View.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-view-value"},{"apiScope":"exported","doc":{"body":"Captured physical window; session-relative indices belong to WindowLink.","summary":"Captured physical window; session-relative indices belong to WindowLink."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::Window","kind":"class","modifiers":[],"name":"Window","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::Window","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":926,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window"},{"apiScope":"exported","doc":{"body":"The physical window's observed active pane.","summary":"The physical window's observed active pane."},"id":"LibTmux::Model::Window.active-pane","kind":"method","modifiers":[],"name":"active-pane","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.active-pane","signatures":[{"params":[],"raw":"method active-pane(--> Pane:D)","references":[{"end":29,"start":23,"target":"LibTmux::Model::Pane"}],"returns":"Pane:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"active-pane","declaration":true},{"text":"(--> "},{"text":"Pane:D","target":"LibTmux::Model::Pane"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":932,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-active-pane"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::Window.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::Window.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-clone"},{"apiScope":"exported","doc":{"body":"Decode retained layout bytes locally, preserving unknown layout versions.","summary":"Decode retained layout bytes locally, preserving unknown layout versions."},"id":"LibTmux::Model::Window.decoded-layout","kind":"method","modifiers":[],"name":"decoded-layout","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.decoded-layout","signatures":[{"params":[],"raw":"method decoded-layout(--> Layout:D)","references":[{"end":34,"start":26,"target":"LibTmux::Layout::Layout"}],"returns":"Layout:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"decoded-layout","declaration":true},{"text":"(--> "},{"text":"Layout:D","target":"LibTmux::Layout::Layout"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":934,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-decoded-layout"},{"apiScope":"exported","doc":{"body":"Captured ` window_height `; local uint access.","summary":"Captured ` window_height `; local uint access."},"id":"LibTmux::Model::Window.height","kind":"method","modifiers":[],"name":"height","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.height","signatures":[{"params":[],"raw":"method height(--> Count:D)","references":[{"end":25,"start":18,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"height","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-height"},{"apiScope":"exported","doc":{"body":"Captured ` window_id `; local window-id access.","summary":"Captured ` window_id `; local window-id access."},"id":"LibTmux::Model::Window.id","kind":"method","modifiers":[],"name":"id","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.id","signatures":[{"params":[],"raw":"method id(--> WindowId:D)","references":[{"end":24,"start":14,"target":"LibTmux::Types::WindowId"}],"returns":"WindowId:D","nativeSyntax":[{"start":7,"end":9,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"id","declaration":true},{"text":"(--> "},{"text":"WindowId:D","target":"LibTmux::Types::WindowId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-id"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::Window.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` window_layout `; local text access.","summary":"Captured ` window_layout `; local text access."},"id":"LibTmux::Model::Window.layout","kind":"method","modifiers":[],"name":"layout","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.layout","signatures":[{"params":[],"raw":"method layout(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"layout","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-layout"},{"apiScope":"exported","doc":{"body":"Captured ` window_linked `; local bool access.","summary":"Captured ` window_linked `; local bool access."},"id":"LibTmux::Model::Window.linked","kind":"method","modifiers":[],"name":"linked","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.linked","signatures":[{"params":[],"raw":"method linked(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"linked","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":67,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-linked"},{"apiScope":"exported","doc":{"body":"All captured placements of this physical window, preserving repeated associations.","summary":"All captured placements of this physical window, preserving repeated associations."},"id":"LibTmux::Model::Window.links","kind":"method","modifiers":[],"name":"links","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.links","signatures":[{"params":[],"raw":"method links(--> WindowLinkSelection:D)","references":[{"end":38,"start":17,"target":"LibTmux::Model::WindowLinkSelection"}],"returns":"WindowLinkSelection:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"links","declaration":true},{"text":"(--> "},{"text":"WindowLinkSelection:D","target":"LibTmux::Model::WindowLinkSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":930,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-links"},{"apiScope":"exported","doc":{"body":"Captured ` window_modal_pane `; local pane-id access.","summary":"Captured ` window_modal_pane `; local pane-id access."},"id":"LibTmux::Model::Window.modal-pane-id","kind":"method","modifiers":[],"name":"modal-pane-id","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.modal-pane-id","signatures":[{"params":[],"raw":"method modal-pane-id(--> PaneId)","references":[{"end":31,"start":25,"target":"LibTmux::Types::PaneId"}],"returns":"PaneId","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"modal-pane-id","declaration":true},{"text":"(--> "},{"text":"PaneId","target":"LibTmux::Types::PaneId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":69,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-modal-pane-id"},{"apiScope":"exported","doc":{"body":"Captured ` window_name `; local text access.","summary":"Captured ` window_name `; local text access."},"id":"LibTmux::Model::Window.name","kind":"method","modifiers":[],"name":"name","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.name","signatures":[{"params":[],"raw":"method name(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"name","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-name"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::Window.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-new"},{"apiScope":"exported","doc":{"body":"Captured physical panes; relation traversal never acquires newer data.","summary":"Captured physical panes; relation traversal never acquires newer data."},"id":"LibTmux::Model::Window.panes","kind":"method","modifiers":[],"name":"panes","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.panes","signatures":[{"params":[],"raw":"method panes(--> PaneSelection:D)","references":[{"end":32,"start":17,"target":"LibTmux::Model::PaneSelection"}],"returns":"PaneSelection:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"panes","declaration":true},{"text":"(--> "},{"text":"PaneSelection:D","target":"LibTmux::Model::PaneSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":928,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-panes"},{"apiScope":"exported","doc":{"body":"Captured ` window_panes `; local uint access.","summary":"Captured ` window_panes `; local uint access."},"id":"LibTmux::Model::Window.panes-count","kind":"method","modifiers":[],"name":"panes-count","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.panes-count","signatures":[{"params":[],"raw":"method panes-count(--> Count:D)","references":[{"end":30,"start":23,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"panes-count","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-panes-count"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::Window.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::Window.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::Window.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-same-entity"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::Window.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::Window.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::Window.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-value"},{"apiScope":"exported","doc":{"body":"Captured ` window_visible_layout `; local text access.","summary":"Captured ` window_visible_layout `; local text access."},"id":"LibTmux::Model::Window.visible-layout","kind":"method","modifiers":[],"name":"visible-layout","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.visible-layout","signatures":[{"params":[],"raw":"method visible-layout(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"visible-layout","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-visible-layout"},{"apiScope":"exported","doc":{"body":"Captured ` window_width `; local uint access.","summary":"Captured ` window_width `; local uint access."},"id":"LibTmux::Model::Window.width","kind":"method","modifiers":[],"name":"width","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.width","signatures":[{"params":[],"raw":"method width(--> Count:D)","references":[{"end":24,"start":17,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"width","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-width"},{"apiScope":"exported","doc":{"body":"Captured ` window_zoomed_flag `; local bool access.","summary":"Captured ` window_zoomed_flag `; local bool access."},"id":"LibTmux::Model::Window.zoomed","kind":"method","modifiers":[],"name":"zoomed","package":"LibTmux","parent":"LibTmux::Model::Window","product":"core","publicId":"LibTmux::Model::Window.zoomed","signatures":[{"params":[],"raw":"method zoomed(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"zoomed","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-window-zoomed"},{"apiScope":"exported","doc":{"body":"One captured session/index association with an expected physical window.","summary":"One captured session/index association with an expected physical window."},"extends":["LibTmux::Model::View"],"id":"LibTmux::Model::WindowLink","kind":"class","modifiers":[],"name":"WindowLink","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::WindowLink","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":919,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink"},{"apiScope":"exported","doc":{"body":"Captured ` window_active `; local bool access.","summary":"Captured ` window_active `; local bool access."},"id":"LibTmux::Model::WindowLink.active","kind":"method","modifiers":[],"name":"active","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.active","signatures":[{"params":[],"raw":"method active(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"active","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":38,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-active"},{"apiScope":"exported","doc":{"body":"Captured ` window_activity_flag `; local bool access.","summary":"Captured ` window_activity_flag `; local bool access."},"id":"LibTmux::Model::WindowLink.activity","kind":"method","modifiers":[],"name":"activity","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.activity","signatures":[{"params":[],"raw":"method activity(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"activity","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":42,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-activity"},{"apiScope":"exported","doc":{"body":"Captured ` window_bell_flag `; local bool access.","summary":"Captured ` window_bell_flag `; local bool access."},"id":"LibTmux::Model::WindowLink.bell","kind":"method","modifiers":[],"name":"bell","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.bell","signatures":[{"params":[],"raw":"method bell(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bell","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":44,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-bell"},{"apiScope":"exported","doc":{"body":"Exact captured bytes, before strict text conversion or normalization.","summary":"Exact captured bytes, before strict text conversion or normalization."},"id":"LibTmux::Model::WindowLink.bytes","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"bytes","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.bytes","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method bytes(Str:D $name --> Blob:D)","references":[],"returns":"Blob:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"bytes","declaration":true},{"text":"(Str:D $name --> Blob:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":854,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-bytes"},{"apiScope":"exported","doc":{"body":"Copy this captured value without changing its records or acquiring new data.","summary":"Copy this captured value without changing its records or acquiring new data."},"id":"LibTmux::Model::WindowLink.clone","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":901,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-clone"},{"apiScope":"exported","doc":{"body":"Return the captured daemon identity without refreshing it.","summary":"Return the captured daemon identity without refreshing it."},"id":"LibTmux::Model::WindowLink.incarnation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.incarnation","signatures":[{"params":[],"raw":"method incarnation(--> Incarnation:D)","references":[{"end":36,"start":23,"target":"LibTmux::Engine::Incarnation"}],"returns":"Incarnation:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"incarnation","declaration":true},{"text":"(--> "},{"text":"Incarnation:D","target":"LibTmux::Engine::Incarnation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":874,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-incarnation"},{"apiScope":"exported","doc":{"body":"Captured ` window_index `; local uint access.","summary":"Captured ` window_index `; local uint access."},"id":"LibTmux::Model::WindowLink.index","kind":"method","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.index","signatures":[{"params":[],"raw":"method index(--> Count:D)","references":[{"end":24,"start":17,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"index","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":36,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-index"},{"apiScope":"exported","doc":{"body":"Captured ` window_last_flag `; local bool access.","summary":"Captured ` window_last_flag `; local bool access."},"id":"LibTmux::Model::WindowLink.last","kind":"method","modifiers":[],"name":"last","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.last","signatures":[{"params":[],"raw":"method last(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"last","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":40,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-last"},{"apiScope":"exported","doc":{"body":"Refuse direct view construction; obtain this value from a Snapshot.","summary":"Refuse direct view construction; obtain this value from a Snapshot."},"id":"LibTmux::Model::WindowLink.new","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(| --> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(| --> Nil)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":825,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-new"},{"apiScope":"exported","doc":{"body":"Construct a value-only command target without observing current daemon state.","summary":"Construct a value-only command target without observing current daemon state."},"id":"LibTmux::Model::WindowLink.ref","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"ref","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.ref","signatures":[{"params":[],"raw":"method ref()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ref","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":877,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-ref"},{"apiScope":"exported","doc":{"body":"Resolve one declared relation locally; incomplete required data raises MissingData.","summary":"Resolve one declared relation locally; incomplete required data raises MissingData."},"id":"LibTmux::Model::WindowLink.relation","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"relation","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.relation","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method relation(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"relation","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":861,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-relation"},{"apiScope":"exported","doc":{"body":"Compare scoped entity identity; window links additionally require the same snapshot.","summary":"Compare scoped entity identity; window links additionally require the same snapshot."},"id":"LibTmux::Model::WindowLink.same-entity","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"View:D"}],"raw":"method same-entity(View:D $other --> Bool:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"("},{"text":"View:D","target":"LibTmux::Model::View"},{"text":" $other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":864,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-same-entity"},{"apiScope":"exported","doc":{"body":"The observed associated session, resolved without I/O.","summary":"The observed associated session, resolved without I/O."},"id":"LibTmux::Model::WindowLink.session","kind":"method","modifiers":[],"name":"session","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.session","signatures":[{"params":[],"raw":"method session(--> Session:D)","references":[{"end":28,"start":19,"target":"LibTmux::Model::Session"}],"returns":"Session:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session","declaration":true},{"text":"(--> "},{"text":"Session:D","target":"LibTmux::Model::Session"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":921,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-session"},{"apiScope":"exported","doc":{"body":"Captured ` session_id `; local session-id access.","summary":"Captured ` session_id `; local session-id access."},"id":"LibTmux::Model::WindowLink.session-id","kind":"method","modifiers":[],"name":"session-id","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.session-id","signatures":[{"params":[],"raw":"method session-id(--> SessionId:D)","references":[{"end":33,"start":22,"target":"LibTmux::Types::SessionId"}],"returns":"SessionId:D","nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"session-id","declaration":true},{"text":"(--> "},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":32,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-session-id"},{"apiScope":"exported","doc":{"body":"Captured ` window_silence_flag `; local bool access.","summary":"Captured ` window_silence_flag `; local bool access."},"id":"LibTmux::Model::WindowLink.silence","kind":"method","modifiers":[],"name":"silence","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.silence","signatures":[{"params":[],"raw":"method silence(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"silence","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":46,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-silence"},{"apiScope":"exported","doc":{"body":"Return the retained captured graph; it owns no live transport.","summary":"Return the retained captured graph; it owns no live transport."},"id":"LibTmux::Model::WindowLink.snapshot","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.snapshot","signatures":[{"params":[],"raw":"method snapshot(--> Snapshot:D)","references":[{"end":30,"start":20,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"(--> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":872,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-snapshot"},{"apiScope":"exported","doc":{"body":"Report availability of a declared field or relation without conflating null and unloaded data.","summary":"Report availability of a declared field or relation without conflating null and unloaded data."},"id":"LibTmux::Model::WindowLink.state","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"state","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.state","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method state(Str:D $name --> ValueState:D)","references":[{"end":41,"start":29,"target":"LibTmux::Types::ValueState"}],"returns":"ValueState:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"state","declaration":true},{"text":"(Str:D $name --> "},{"text":"ValueState:D","target":"LibTmux::Types::ValueState"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":831,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-state"},{"apiScope":"exported","doc":{"body":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data.","summary":"Return a decoded local field, Nil for known null, or throw MissingData for unavailable data."},"id":"LibTmux::Model::WindowLink.value","inheritedFrom":"LibTmux::Model::View","kind":"method","modifiers":[],"name":"value","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.value","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method value(Str:D $name)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"value","declaration":true},{"text":"(Str:D $name)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":846,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-value"},{"apiScope":"exported","doc":{"body":"The observed physical window, resolved without I/O.","summary":"The observed physical window, resolved without I/O."},"id":"LibTmux::Model::WindowLink.window","kind":"method","modifiers":[],"name":"window","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.window","signatures":[{"params":[],"raw":"method window(--> Window:D)","references":[{"end":26,"start":18,"target":"LibTmux::Model::Window"}],"returns":"Window:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window","declaration":true},{"text":"(--> "},{"text":"Window:D","target":"LibTmux::Model::Window"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":923,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-window"},{"apiScope":"exported","doc":{"body":"Captured ` window_id `; local window-id access.","summary":"Captured ` window_id `; local window-id access."},"id":"LibTmux::Model::WindowLink.window-id","kind":"method","modifiers":[],"name":"window-id","package":"LibTmux","parent":"LibTmux::Model::WindowLink","product":"core","publicId":"LibTmux::Model::WindowLink.window-id","signatures":[{"params":[],"raw":"method window-id(--> WindowId:D)","references":[{"end":31,"start":21,"target":"LibTmux::Types::WindowId"}],"returns":"WindowId:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"window-id","declaration":true},{"text":"(--> "},{"text":"WindowId:D","target":"LibTmux::Types::WindowId"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Fields.rakumod","line":34,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlink-window-id"},{"apiScope":"exported","doc":{"body":"A session/index target with an expected window. Renumbering checks are not atomic.","summary":"A session/index target with an expected window. Renumbering checks are not atomic."},"id":"LibTmux::Model::WindowLinkRef","kind":"class","modifiers":[],"name":"WindowLinkRef","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::WindowLinkRef","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":499,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref"},{"apiScope":"exported","doc":{"body":"Captured connection settings; retaining them owns no process.","summary":"Captured connection settings; retaining them owns no process."},"id":"LibTmux::Model::WindowLinkRef.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":501,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-model-windowlinkref-endpoint"},{"apiScope":"exported","doc":{"body":"Captured daemon identity used to reject references after replacement.","summary":"Captured daemon identity used to reject references after replacement."},"id":"LibTmux::Model::WindowLinkRef.incarnation","kind":"property","modifiers":[],"name":"incarnation","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.incarnation","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":503,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Incarnation:D","slug":"libtmux-model-windowlinkref-incarnation"},{"apiScope":"exported","doc":{"body":"Captured session-relative index; it can change after renumbering.","summary":"Captured session-relative index; it can change after renumbering."},"id":"LibTmux::Model::WindowLinkRef.index","kind":"property","modifiers":[],"name":"index","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.index","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":509,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"libtmux-model-windowlinkref-index"},{"apiScope":"exported","doc":{"body":"Move this association; tmux also synchronizes the affected session groups.","summary":"Move this association; tmux also synchronizes the affected session groups."},"id":"LibTmux::Model::WindowLinkRef.move","kind":"method","modifiers":[],"name":"move","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.move","signatures":[{"params":[{"keywordOnly":false,"name":"$session","optional":false,"type":"SessionRef:D"},{"keywordOnly":true,"name":"$index","optional":false,"type":"Count:D"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$replace","optional":true,"type":"Bool"}],"raw":"method move(SessionRef:D $session, Count:D :$index!, Bool :$select = False,\n                Bool :$replace = False --> WindowLinkRef:D)","references":[{"end":24,"start":12,"target":"LibTmux::Model::SessionRef"},{"end":42,"start":35,"target":"LibTmux::Types::Count"},{"end":134,"start":119,"target":"LibTmux::Model::WindowLinkRef"}],"returns":"WindowLinkRef:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"move","declaration":true},{"text":"("},{"text":"SessionRef:D","target":"LibTmux::Model::SessionRef"},{"text":" $session, "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":" :$index!, Bool :$select = False,\n                Bool :$replace = False --> "},{"text":"WindowLinkRef:D","target":"LibTmux::Model::WindowLinkRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":545,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref-move"},{"apiScope":"exported","doc":{"body":"Select the exact pane or verified session-relative window placement.","summary":"Select the exact pane or verified session-relative window placement."},"id":"LibTmux::Model::WindowLinkRef.select","kind":"method","modifiers":[],"name":"select","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.select","signatures":[{"params":[],"raw":"method select(--> Result:D)","references":[{"end":26,"start":18,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"select","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":531,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref-select"},{"apiScope":"exported","doc":{"body":"Captured session identity for this observed window placement.","summary":"Captured session identity for this observed window placement."},"id":"LibTmux::Model::WindowLinkRef.session-id","kind":"property","modifiers":[],"name":"session-id","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.session-id","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":505,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SessionId:D","slug":"libtmux-model-windowlinkref-session-id"},{"apiScope":"exported","doc":{"body":"Swap the two verified pane identities or session-relative window placements.","summary":"Swap the two verified pane identities or session-relative window placements."},"id":"LibTmux::Model::WindowLinkRef.swap","kind":"method","modifiers":[],"name":"swap","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.swap","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false,"type":"WindowLinkRef:D"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"}],"raw":"method swap(WindowLinkRef:D $other, Bool :$select = False --> Result:D)","references":[{"end":27,"start":12,"target":"LibTmux::Model::WindowLinkRef"},{"end":70,"start":62,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"swap","declaration":true},{"text":"("},{"text":"WindowLinkRef:D","target":"LibTmux::Model::WindowLinkRef"},{"text":" $other, Bool :$select = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":557,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref-swap"},{"apiScope":"exported","doc":{"body":"Return the observed session:index target without checking whether it remains current.","summary":"Return the observed session:index target without checking whether it remains current."},"id":"LibTmux::Model::WindowLinkRef.target","kind":"method","modifiers":[],"name":"target","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.target","signatures":[{"params":[],"raw":"method target(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"target","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":512,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref-target"},{"apiScope":"exported","doc":{"body":"Remove this placement and its grouped-session peers; kill-last permits the last link.","summary":"Remove this placement and its grouped-session peers; kill-last permits the last link."},"id":"LibTmux::Model::WindowLinkRef.unlink","kind":"method","modifiers":[],"name":"unlink","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.unlink","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$kill-last","optional":true,"type":"Bool"}],"raw":"method unlink(Bool :$kill-last = False --> Result:D)","references":[{"end":51,"start":43,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"unlink","declaration":true},{"text":"(Bool :$kill-last = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":538,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkref-unlink"},{"apiScope":"exported","doc":{"body":"Expected physical window identity at the captured session index.","summary":"Expected physical window identity at the captured session index."},"id":"LibTmux::Model::WindowLinkRef.window-id","kind":"property","modifiers":[],"name":"window-id","package":"LibTmux","parent":"LibTmux::Model::WindowLinkRef","product":"core","publicId":"LibTmux::Model::WindowLinkRef.window-id","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":507,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"WindowId:D","slug":"libtmux-model-windowlinkref-window-id"},{"apiScope":"exported","doc":{"body":"Replayable typed window-link membership with local filtering.","summary":"Replayable typed window-link membership with local filtering."},"id":"LibTmux::Model::WindowLinkSelection","kind":"class","modifiers":[],"name":"WindowLinkSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::WindowLinkSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":962,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::WindowLinkSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::WindowLinkSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::WindowLinkSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::WindowLinkSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::WindowLinkSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-list-1m9h"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::WindowLinkSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::WindowLinkSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::WindowLinkSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::WindowLinkSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::WindowLinkSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::WindowLinkSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::WindowLinkSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::WindowLinkSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::WindowLinkSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::WindowLinkSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::WindowLinkSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-list-nhhc"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::WindowLinkSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::WindowLinkSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::WindowLinkSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::WindowLinkSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::WindowLinkSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::WindowLinkSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::WindowLinkSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::WindowLinkSelection","product":"core","publicId":"LibTmux::Model::WindowLinkSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowlinkselection-where"},{"apiScope":"exported","doc":{"body":"Value-only command target for a physical window, independent of its links.","summary":"Value-only command target for a physical window, independent of its links."},"id":"LibTmux::Model::WindowRef","kind":"class","modifiers":[],"name":"WindowRef","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::WindowRef","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":172,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref"},{"apiScope":"exported","doc":{"body":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics.","summary":"A bounded, identity-guarded explicit command. Arguments keep tmux semantics."},"id":"LibTmux::Model::WindowRef.command","kind":"method","modifiers":["overload","overload","overload"],"name":"command","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.command","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method command(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"(|operation)"}]},{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"Blob.new","keywordOnly":true,"name":"$stdin","optional":true,"type":"Blob:D"}],"raw":"method command(Invocation:D $command, Blob:D :$stdin = Blob.new --> Result:D)","references":[{"end":27,"start":15,"target":"LibTmux::Command::Invocation"},{"end":76,"start":68,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, Blob:D :$stdin = Blob.new --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-command"},{"apiScope":"exported","doc":{"body":"Return the registered entity schema without I/O.","summary":"Return the registered entity schema without I/O."},"id":"LibTmux::Model::WindowRef.entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":71,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-entity"},{"apiScope":"exported","doc":{"body":"Construct a value-only hook facade; its reads and writes are explicit operations.","summary":"Construct a value-only hook facade; its reads and writes are explicit operations."},"id":"LibTmux::Model::WindowRef.hooks","kind":"method","modifiers":[],"name":"hooks","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.hooks","signatures":[{"params":[],"raw":"method hooks(--> Hooks:D)","references":[{"end":24,"start":17,"target":"LibTmux::Configuration::Hooks"}],"returns":"Hooks:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"hooks","declaration":true},{"text":"(--> "},{"text":"Hooks:D","target":"LibTmux::Configuration::Hooks"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":79,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-hooks"},{"apiScope":"exported","doc":{"body":"Acquire a fresh graph and require exactly one observed entity with this ID.","summary":"Acquire a fresh graph and require exactly one observed entity with this ID."},"id":"LibTmux::Model::WindowRef.inspect","kind":"method","modifiers":["overload","overload","overload"],"name":"inspect","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.inspect","signatures":[{"params":[{"keywordOnly":false,"name":"operation","optional":false}],"raw":"method inspect(|operation)","references":[],"nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(|operation)"}]},{"params":[],"raw":"method inspect(--> View:D)","references":[{"end":25,"start":19,"target":"LibTmux::Model::View"}],"returns":"View:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"inspect","declaration":true},{"text":"(--> "},{"text":"View:D","target":"LibTmux::Model::View"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":101,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-inspect"},{"apiScope":"exported","doc":{"body":"Destroy the addressed entity; retained observations remain unchanged.","summary":"Destroy the addressed entity; retained observations remain unchanged."},"id":"LibTmux::Model::WindowRef.kill","kind":"method","modifiers":[],"name":"kill","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.kill","signatures":[{"params":[],"raw":"method kill(--> Result:D)","references":[{"end":24,"start":16,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"kill","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":239,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-kill"},{"apiScope":"exported","doc":{"body":"Select the previous active pane in this physical window.","summary":"Select the previous active pane in this physical window."},"id":"LibTmux::Model::WindowRef.last-pane","kind":"method","modifiers":[],"name":"last-pane","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.last-pane","signatures":[{"params":[],"raw":"method last-pane(--> Result:D)","references":[{"end":29,"start":21,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"last-pane","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":206,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-last-pane"},{"apiScope":"exported","doc":{"body":"Add a destination placement. tmux synchronizes placements across session groups.","summary":"Add a destination placement. tmux synchronizes placements across session groups."},"id":"LibTmux::Model::WindowRef.link","kind":"method","modifiers":[],"name":"link","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.link","signatures":[{"params":[{"keywordOnly":false,"name":"$session","optional":false,"type":"SessionRef:D"},{"keywordOnly":true,"name":"$index","optional":false,"type":"Count:D"},{"default":"False","keywordOnly":true,"name":"$select","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$replace","optional":true,"type":"Bool"}],"raw":"method link(SessionRef:D $session, Count:D :$index!, Bool :$select = False,\n                Bool :$replace = False --> WindowLinkRef:D)","references":[{"end":24,"start":12,"target":"LibTmux::Model::SessionRef"},{"end":42,"start":35,"target":"LibTmux::Types::Count"},{"end":134,"start":119,"target":"LibTmux::Model::WindowLinkRef"}],"returns":"WindowLinkRef:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"link","declaration":true},{"text":"("},{"text":"SessionRef:D","target":"LibTmux::Model::SessionRef"},{"text":" $session, "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":" :$index!, Bool :$select = False,\n                Bool :$replace = False --> "},{"text":"WindowLinkRef:D","target":"LibTmux::Model::WindowLinkRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":219,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-link"},{"apiScope":"exported","doc":{"body":"Apply the next tmux layout to this physical window.","summary":"Apply the next tmux layout to this physical window."},"id":"LibTmux::Model::WindowRef.next-layout","kind":"method","modifiers":[],"name":"next-layout","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.next-layout","signatures":[{"params":[],"raw":"method next-layout(--> Result:D)","references":[{"end":31,"start":23,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"next-layout","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":200,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-next-layout"},{"apiScope":"exported","doc":{"body":"Construct a value-only option facade scoped to this captured identity.","summary":"Construct a value-only option facade scoped to this captured identity."},"id":"LibTmux::Model::WindowRef.options","kind":"method","modifiers":[],"name":"options","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.options","signatures":[{"params":[],"raw":"method options(--> Options:D)","references":[{"end":28,"start":19,"target":"LibTmux::Configuration::Options"}],"returns":"Options:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"options","declaration":true},{"text":"(--> "},{"text":"Options:D","target":"LibTmux::Configuration::Options"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-options"},{"apiScope":"exported","doc":{"body":"Apply the previous tmux layout to this physical window.","summary":"Apply the previous tmux layout to this physical window."},"id":"LibTmux::Model::WindowRef.previous-layout","kind":"method","modifiers":[],"name":"previous-layout","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.previous-layout","signatures":[{"params":[],"raw":"method previous-layout(--> Result:D)","references":[{"end":35,"start":27,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"previous-layout","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":202,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-previous-layout"},{"apiScope":"exported","doc":{"body":"Store the exact name; refuse characters or separators the daemon would change.","summary":"Store the exact name; refuse characters or separators the daemon would change."},"id":"LibTmux::Model::WindowRef.rename","kind":"method","modifiers":[],"name":"rename","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.rename","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method rename(Str:D $name --> Result:D)","references":[{"end":38,"start":30,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"rename","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":174,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-rename"},{"apiScope":"exported","doc":{"body":"Set absolute dimensions or adjust one direction; these forms cannot be mixed.","summary":"Set absolute dimensions or adjust one direction; these forms cannot be mixed."},"id":"LibTmux::Model::WindowRef.resize","kind":"method","modifiers":[],"name":"resize","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.resize","signatures":[{"params":[{"default":"Positive","keywordOnly":true,"name":"$width","optional":true},{"default":"Positive","keywordOnly":true,"name":"$height","optional":true},{"keywordOnly":true,"name":"$direction","optional":true,"type":"Str"},{"default":"Positive","keywordOnly":true,"name":"$amount","optional":true}],"raw":"method resize(:$width = Positive, :$height = Positive, Str :$direction, :$amount = Positive --> Result:D)","references":[{"end":32,"start":24,"target":"LibTmux::Types::Positive"},{"end":53,"start":45,"target":"LibTmux::Types::Positive"},{"end":91,"start":83,"target":"LibTmux::Types::Positive"},{"end":104,"start":96,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"resize","declaration":true},{"text":"(:$width = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", :$height = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":", Str :$direction, :$amount = "},{"text":"Positive","target":"LibTmux::Types::Positive"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":179,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-resize"},{"apiScope":"exported","doc":{"body":"Restart the target's process; kill must be explicit when replacing a running process.","summary":"Restart the target's process; kill must be explicit when replacing a running process."},"id":"LibTmux::Model::WindowRef.respawn","kind":"method","modifiers":[],"name":"respawn","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.respawn","signatures":[{"params":[{"keywordOnly":true,"name":"$shell-command","optional":true,"type":"Str"},{"keywordOnly":true,"name":"$directory","optional":true,"type":"Str"},{"default":"False","keywordOnly":true,"name":"$kill","optional":true,"type":"Bool"},{"default":"Map.new","keywordOnly":true,"name":"$environment","optional":true,"type":"Associative:D"}],"raw":"method respawn(Str :$shell-command, Str :$directory, Bool :$kill = False,\n                   Associative:D :$environment = Map.new --> Result:D)","references":[{"end":143,"start":135,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"respawn","declaration":true},{"text":"(Str :$shell-command, Str :$directory, Bool :$kill = False,\n                   Associative:D :$environment = Map.new --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":213,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-respawn"},{"apiScope":"exported","doc":{"body":"Validate and apply serialized layout bytes in the daemon's declared dialect.","summary":"Validate and apply serialized layout bytes in the daemon's declared dialect."},"id":"LibTmux::Model::WindowRef.restore-layout","kind":"method","modifiers":[],"name":"restore-layout","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.restore-layout","signatures":[{"params":[{"keywordOnly":false,"name":"$layout","optional":false,"type":"Blob:D"}],"raw":"method restore-layout(Blob:D $layout --> Result:D)","references":[{"end":49,"start":41,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"restore-layout","declaration":true},{"text":"(Blob:D $layout --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":193,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-restore-layout"},{"apiScope":"exported","doc":{"body":"Rotate panes in the layout; reverse changes the rotation direction.","summary":"Rotate panes in the layout; reverse changes the rotation direction."},"id":"LibTmux::Model::WindowRef.rotate","kind":"method","modifiers":[],"name":"rotate","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.rotate","signatures":[{"params":[{"default":"False","keywordOnly":true,"name":"$reverse","optional":true,"type":"Bool"},{"default":"False","keywordOnly":true,"name":"$preserve-zoom","optional":true,"type":"Bool"}],"raw":"method rotate(Bool :$reverse = False, Bool :$preserve-zoom = False --> Result:D)","references":[{"end":79,"start":71,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"rotate","declaration":true},{"text":"(Bool :$reverse = False, Bool :$preserve-zoom = False --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":208,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-rotate"},{"apiScope":"exported","doc":{"body":"Compare scoped identity without acquiring current state.","summary":"Compare scoped identity without acquiring current state."},"id":"LibTmux::Model::WindowRef.same-entity","kind":"method","modifiers":[],"name":"same-entity","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.same-entity","signatures":[{"params":[{"keywordOnly":false,"name":"$other","optional":false}],"raw":"method same-entity($other --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"same-entity","declaration":true},{"text":"($other --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":116,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-same-entity"},{"apiScope":"exported","doc":{"body":"Select a named layout. Serialized layouts use restore-layout instead.","summary":"Select a named layout. Serialized layouts use restore-layout instead."},"id":"LibTmux::Model::WindowRef.select-layout","kind":"method","modifiers":[],"name":"select-layout","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.select-layout","signatures":[{"params":[{"keywordOnly":false,"name":"$name","optional":false,"type":"Str:D"}],"raw":"method select-layout(Str:D $name --> Result:D)","references":[{"end":45,"start":37,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"select-layout","declaration":true},{"text":"(Str:D $name --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":184,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-select-layout"},{"apiScope":"exported","doc":{"body":"Distribute space evenly around the active pane using select-layout -E.","summary":"Distribute space evenly around the active pane using select-layout -E."},"id":"LibTmux::Model::WindowRef.spread-layout","kind":"method","modifiers":[],"name":"spread-layout","package":"LibTmux","parent":"LibTmux::Model::WindowRef","product":"core","publicId":"LibTmux::Model::WindowRef.spread-layout","signatures":[{"params":[],"raw":"method spread-layout(--> Result:D)","references":[{"end":33,"start":25,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"spread-layout","declaration":true},{"text":"(--> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Model.rakumod","line":204,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowref-spread-layout"},{"apiScope":"exported","doc":{"body":"Replayable typed window membership with local filtering.","summary":"Replayable typed window membership with local filtering."},"id":"LibTmux::Model::WindowSelection","kind":"class","modifiers":[],"name":"WindowSelection","package":"LibTmux","parent":"LibTmux::Model","product":"core","publicId":"LibTmux::Model::WindowSelection","signatures":[],"source":{"file":"lib/LibTmux/Model.rakumod","line":964,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Model::WindowSelection.AT-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Model::WindowSelection.Array","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Model::WindowSelection.Bool","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Model::WindowSelection.EXISTS-POS","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Model::WindowSelection.List","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-list-12o0"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Model::WindowSelection.Seq","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Model::WindowSelection.all","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Model::WindowSelection.any","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Model::WindowSelection.clone","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Model::WindowSelection.elems","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Model::WindowSelection.entity","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Model::WindowSelection.filter","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Model::WindowSelection.first","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Model::WindowSelection.grep","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Model::WindowSelection.iterator","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Model::WindowSelection.list","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-list-33ny"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Model::WindowSelection.map","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Model::WindowSelection.none","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Model::WindowSelection.one","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Model::WindowSelection.single","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Model::WindowSelection.single-or-nil","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Model::WindowSelection.sort","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Model::WindowSelection.where","inheritedFrom":"LibTmux::Selection::Selection","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Model::WindowSelection","product":"core","publicId":"LibTmux::Model::WindowSelection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-model-windowselection-where"},{"apiScope":"exported","doc":{"body":"# Validated local criteria\n\n` Filter.compile(%criteria, :entity<pane>) ` validates and copies one\ncriterion before any entity is read. ` matches($view) ` and native smartmatching\nthrough ` ACCEPTS ` use the same evaluator. The view protocol has four fixed\nmethods: ` entity `, ` state($name) `, ` value($name) ` and ` relation($name) `.\nNames are checked against the catalogue; input keys never become method calls.\n\nField values abbreviate equality. Operator mappings support ` equals `,\n` not-equals `, ` in `, ` not-in `, numeric ` lt/lte/gt/gte `, literal ` contains `,\n` starts-with `, ` ends-with `, and nullable fields' ` is-null `. Operators and\nfields at the same level are conjoined. Numeric operands exclude Bool and\nnon-finite values. Text is NFC normalized and literal matching compares\ncodepoints, including positions inside a grapheme. Invalid UTF8-C8 bytes are\nrefused; byte comparison belongs to a separate interface.\n\n` AND ` and ` OR ` accept collections of complete criteria. ` NOT ` accepts one\ncriterion. Empty criteria and AND are true; empty OR and in are false; empty\nnot-in is true. Boolean evaluation short-circuits after schema validation.\nFor example, an OR whose first branch matches does not read an unloaded field\nin its second branch. Unknown fields in either branch still fail compilation.\n\nTo-many relations support ` some `, ` every ` and ` none `. One ` some ` requires\none child to satisfy its complete subtree. Separate existential subtrees may\nuse different children. Loaded empty relations yield false, true and true,\nrespectively. To-one relations support ` is `, ` is-not `, and ` is-null ` where\nthe relation is nullable. No evaluation performs I/O.\n\nKnownNull satisfies only an explicit null test. For example,\n` dead-status => %(not-equals => 0) ` is false when status is KnownNull;\n` NOT => %(dead-status => %(not-equals => 0)) ` is true. Likewise a\nnull group fails both ` is ` and ` is-not `. Unsupported, Unavailable and Unloaded\nstates throw MissingData when evaluated. They are never empty relations,\nempty strings, zero or false.\n\n` criteria ` exposes normalized nested Maps and Lists. ` ast ` exposes immutable\nnodes for source planning: kind, entity, name, wire-name, operator, field-kind,\ntarget, operand and children. Cloning a Filter is refused; compile changed data\nto preserve validation. Native callbacks, Junctions, regexes, type objects,\nlazy collections and cycles are not criterion data.\n\n\n\n# Proposed JSON representation\n\n` to-json ` and ` Filter.from-json(Str|Blob) ` use JSON::Fast and the proposed\n` libtmux.where/v1 ` envelope with exactly ` schema `, ` entity ` and ` where `.\nThis is a Raku proposal, not a claim of tested cross-port wire compatibility.\nCatalogue wire names are stable camelCase names; compound operator names use\ncamelCase too, such as ` notEquals `, ` startsWith `, ` isNull ` and ` isNot `.\nJSON::Fast uses the last value for a duplicate object key.\nThe bounded preflight also rejects malformed numeric spellings and raw control\ncharacters in strings; parsing remains delegated to JSON::Fast.\n\nWire numbers use finite binary64 values bounded in absolute magnitude by\n` 2**53-1 `, with integers in that safe range kept exact. Decimal JSON operands\nare interpreted as binary64. Export of an exact Rat or FatRat requires a\npower-of-two denominator, a numerator below 2**53 in absolute magnitude and\na lossless nonzero binary64 conversion. In particular, local ` 1/3 ` criteria\nremain valid but cannot be serialized by rounding to ` 0.333333 `. JSON numeric\ntokens are limited to 64 characters and exponents to absolute value 324;\noverflow and nonzero underflow are refused.\n\nLimits defaults are 1 MiB wire input/output, depth 32, 4096 copied value nodes\nand 1024 membership operands. Byte length and structural JSON depth are checked\nbefore parsing while respecting quoted strings and escapes. Native and decoded\ncriteria then share bounded recursive validation. Supply an immutable Limits\nvalue to compile or from-json to choose tighter limits.","summary":""},"id":"LibTmux::Query","kind":"module","modifiers":[],"name":"Query","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Query","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":2,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query"},{"apiScope":"exported","doc":{"body":"A schema-validated local matcher with copied, immutable criteria and AST.","summary":"A schema-validated local matcher with copied, immutable criteria and AST."},"id":"LibTmux::Query::Filter","kind":"class","modifiers":[],"name":"Filter","package":"LibTmux","parent":"LibTmux::Query","product":"core","publicId":"LibTmux::Query::Filter","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":356,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter"},{"apiScope":"exported","doc":{"body":"Participate as a native matcher without changing data equality semantics.","summary":"Participate as a native matcher without changing data equality semantics."},"id":"LibTmux::Query::Filter.ACCEPTS","kind":"method","modifiers":[],"name":"ACCEPTS","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.ACCEPTS","signatures":[{"params":[{"keywordOnly":false,"name":"$view","optional":false,"type":"Mu"}],"raw":"method ACCEPTS(Filter:D: Mu $view --> Bool:D)","references":[{"end":23,"start":15,"target":"LibTmux::Query::Filter"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"ACCEPTS","declaration":true},{"text":"("},{"text":"Filter:D","target":"LibTmux::Query::Filter"},{"text":": Mu $view --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":390,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-accepts"},{"apiScope":"exported","doc":{"body":"Validated immutable expression tree used by matches and ACCEPTS.","summary":"Validated immutable expression tree used by matches and ACCEPTS."},"id":"LibTmux::Query::Filter.ast","kind":"property","modifiers":[],"name":"ast","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.ast","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":364,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Node:D","slug":"libtmux-query-filter-ast"},{"apiScope":"exported","doc":{"body":"Recompile changed criteria instead of bypassing validation with Mu.clone.","summary":"Recompile changed criteria instead of bypassing validation with Mu.clone."},"id":"LibTmux::Query::Filter.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":369,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-clone"},{"apiScope":"exported","doc":{"body":"Validate the entire criterion before observing any member.","summary":"Validate the entire criterion before observing any member."},"id":"LibTmux::Query::Filter.compile","kind":"method","modifiers":[],"name":"compile","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.compile","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"},{"keywordOnly":true,"name":"$entity","optional":false,"type":"Mu"},{"default":"Limits.new","keywordOnly":true,"name":"$limits","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method compile(Mu $criteria, Mu :$entity!, Mu :$limits = Limits.new,\n                   *%unknown --> Filter:D)","references":[{"end":63,"start":57,"target":"LibTmux::Query::Limits"},{"end":110,"start":102,"target":"LibTmux::Query::Filter"}],"returns":"Filter:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"compile","declaration":true},{"text":"(Mu $criteria, Mu :$entity!, Mu :$limits = "},{"text":"Limits","target":"LibTmux::Query::Limits"},{"text":".new,\n                   *%unknown --> "},{"text":"Filter:D","target":"LibTmux::Query::Filter"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":371,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-compile"},{"apiScope":"exported","doc":{"body":"Deep-copied normalized query data, independent of the caller containers.","summary":"Deep-copied normalized query data, independent of the caller containers."},"id":"LibTmux::Query::Filter.criteria","kind":"property","modifiers":[],"name":"criteria","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.criteria","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":362,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Map:D","slug":"libtmux-query-filter-criteria"},{"apiScope":"exported","doc":{"body":"Entity schema against which every field and relationship was validated.","summary":"Entity schema against which every field and relationship was validated."},"id":"LibTmux::Query::Filter.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.entity","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":358,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-filter-entity"},{"apiScope":"exported","doc":{"body":"Bound bytes and nesting before JSON::Fast, then validate the closed wire grammar.","summary":"Bound bytes and nesting before JSON::Fast, then validate the closed wire grammar."},"id":"LibTmux::Query::Filter.from-json","kind":"method","modifiers":[],"name":"from-json","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.from-json","signatures":[{"params":[{"keywordOnly":false,"name":"$input","optional":false,"type":"Mu"},{"default":"Limits.new","keywordOnly":true,"name":"$limits","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method from-json(Mu $input, Mu :$limits = Limits.new, *%unknown --> Filter:D)","references":[{"end":48,"start":42,"target":"LibTmux::Query::Limits"},{"end":76,"start":68,"target":"LibTmux::Query::Filter"}],"returns":"Filter:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"from-json","declaration":true},{"text":"(Mu $input, Mu :$limits = "},{"text":"Limits","target":"LibTmux::Query::Limits"},{"text":".new, *%unknown --> "},{"text":"Filter:D","target":"LibTmux::Query::Filter"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":399,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-from-json"},{"apiScope":"exported","doc":{"body":"Immutable validation and serialization bounds used by this compiled filter.","summary":"Immutable validation and serialization bounds used by this compiled filter."},"id":"LibTmux::Query::Filter.limits","kind":"property","modifiers":[],"name":"limits","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.limits","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":360,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Limits:D","slug":"libtmux-query-filter-limits"},{"apiScope":"exported","doc":{"body":"Evaluate locally using the fixed entity/state/value/relation view protocol.","summary":"Evaluate locally using the fixed entity/state/value/relation view protocol."},"id":"LibTmux::Query::Filter.matches","kind":"method","modifiers":[],"name":"matches","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.matches","signatures":[{"params":[{"keywordOnly":false,"name":"$view","optional":false}],"raw":"method matches($view --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"matches","declaration":true},{"text":"($view --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":385,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-matches"},{"apiScope":"exported","doc":{"body":"Refuse unvalidated construction; use compile or from-json.","summary":"Refuse unvalidated construction; use compile or from-json."},"id":"LibTmux::Query::Filter.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":367,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-new"},{"apiScope":"exported","doc":{"body":"Encode the proposed wire schema; reject exact numbers that would round.","summary":"Encode the proposed wire schema; reject exact numbers that would round."},"id":"LibTmux::Query::Filter.to-json","kind":"method","modifiers":[],"name":"to-json","package":"LibTmux","parent":"LibTmux::Query::Filter","product":"core","publicId":"LibTmux::Query::Filter.to-json","signatures":[{"params":[],"raw":"method to-json(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"to-json","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Query.rakumod","line":392,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-filter-to-json"},{"apiScope":"exported","doc":{"body":"Immutable resource limits applied before recursive validation or JSON parsing.","summary":"Immutable resource limits applied before recursive validation or JSON parsing."},"id":"LibTmux::Query::Limits","kind":"class","modifiers":[],"name":"Limits","package":"LibTmux","parent":"LibTmux::Query","product":"core","publicId":"LibTmux::Query::Limits","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":10,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-limits"},{"apiScope":"exported","doc":{"body":"Maximum recursive criterion nesting depth.","summary":"Maximum recursive criterion nesting depth."},"id":"LibTmux::Query::Limits.max-depth","kind":"property","modifiers":[],"name":"max-depth","package":"LibTmux","parent":"LibTmux::Query::Limits","product":"core","publicId":"LibTmux::Query::Limits.max-depth","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":14,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-query-limits-max-depth"},{"apiScope":"exported","doc":{"body":"Maximum operands in one membership criterion.","summary":"Maximum operands in one membership criterion."},"id":"LibTmux::Query::Limits.max-members","kind":"property","modifiers":[],"name":"max-members","package":"LibTmux","parent":"LibTmux::Query::Limits","product":"core","publicId":"LibTmux::Query::Limits.max-members","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":18,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-query-limits-max-members"},{"apiScope":"exported","doc":{"body":"Maximum copied criterion nodes, including operands and containers.","summary":"Maximum copied criterion nodes, including operands and containers."},"id":"LibTmux::Query::Limits.max-nodes","kind":"property","modifiers":[],"name":"max-nodes","package":"LibTmux","parent":"LibTmux::Query::Limits","product":"core","publicId":"LibTmux::Query::Limits.max-nodes","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":16,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-query-limits-max-nodes"},{"apiScope":"exported","doc":{"body":"Maximum serialized filter bytes before JSON decoding or after encoding.","summary":"Maximum serialized filter bytes before JSON decoding or after encoding."},"id":"LibTmux::Query::Limits.max-wire-bytes","kind":"property","modifiers":[],"name":"max-wire-bytes","package":"LibTmux","parent":"LibTmux::Query::Limits","product":"core","publicId":"LibTmux::Query::Limits.max-wire-bytes","signatures":[],"source":{"file":"lib/LibTmux/Query.rakumod","line":12,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-query-limits-max-wire-bytes"},{"apiScope":"exported","doc":{"body":"# Planning an explicit read\n\n` Plan.compile($filter, :$capabilities) ` performs no I/O. ` auto ` uses proven\nscalar restrictions; ` never ` leaves filtering local; ` require ` throws unless\nthe complete predicate has an exact source implementation. The capability\nvalue must come from the daemon incarnation that will execute the read.\n\nFor ` acquisition-mode ` ` listing `, pass ` projection ` and ` candidate-command `\ntogether to the guarded reader. The command does not include ` -F `: the reader\nadds the projection's template. Normalize physical entity IDs or session/index\nlink keys according to ` identity-normalization `, then apply ` matches ` to every\ncandidate. It always evaluates the original validated filter, including when\n` fully-pushed ` is true.\n\nFor ` full-graph `, acquire one complete snapshot and apply ` matches ` to its\nroot entities. Do not execute the candidate command. ` source-filter ` is empty;\n` acquisition-reason ` explains why an otherwise eligible scalar restriction is\ndeferred. ` required-relations ` retains each relationship path. Filtering child\nrows first would change ` every ` and ` none `, and intersecting a separately\nacquired candidate set with a later graph can lose matches during mutation.\n\n\n\n# Inspecting source work\n\n` steps ` exposes the translation tree, paths, exactness, expressions and refusal\nreasons. Eligible conjuncts can restrict candidates while text remains local.\nAn AND restriction follows the captured evaluator order and stops at the first\nresidual subtree, retaining that subtree's own safe prefix if present. It never\nmoves a later restriction ahead of local work that may throw. Use an explicit\nAND array when the ordering of residual evaluation matters; hash iteration is\nnot an ordering contract.\nAn OR or NOT subtree is emitted only when the complete subtree is exact.\nText and relationship predicates remain local. Empty Boolean and membership\nnodes retain the same identities as the local query evaluator.\n\nID matching uses tmux string equality. Flags use exact zero/one equality.\nNumeric comparisons use arithmetic FORMAT expressions, never lexical ordering.\nThe catalogue records source-proven UInt32 dimension and nonnegative Int32\nwindow-index domains. Only integer operands within the exact IEEE-754 integer\nrange are eligible. Bounded operands alone cannot establish source equivalence:\nthe observed field's complete domain must also fit the arithmetic conversion.\nFractional operands, nullable fields and unqualified numeric fields stay local.\n\nBoolean expressions are balanced and bounded by bytes and nesting depth. An\noversized expression remains local under ` auto ` and is refused by ` require `.\nThe guarded reader still enforces its own complete command/output/time limits.","summary":""},"id":"LibTmux::Query::Plan","kind":"module","modifiers":[],"name":"Plan","package":"LibTmux","parent":"LibTmux::Query","product":"core","publicId":"LibTmux::Query::Plan","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan"},{"apiScope":"exported","doc":{"body":"Pure, inspectable source restrictions plus the original local filter.","summary":"Pure, inspectable source restrictions plus the original local filter."},"id":"LibTmux::Query::Plan::Plan","kind":"class","modifiers":[],"name":"Plan","package":"LibTmux","parent":"LibTmux::Query::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":171,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan"},{"apiScope":"exported","doc":{"body":"Acquire one listing or a full graph; relation predicates require full-graph.","summary":"Acquire one listing or a full graph; relation predicates require full-graph."},"id":"LibTmux::Query::Plan::Plan.acquisition-mode","kind":"property","modifiers":[],"name":"acquisition-mode","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.acquisition-mode","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":183,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-acquisition-mode"},{"apiScope":"exported","doc":{"body":"Why the plan selected its acquisition mode and source restriction policy.","summary":"Why the plan selected its acquisition mode and source restriction policy."},"id":"LibTmux::Query::Plan::Plan.acquisition-reason","kind":"property","modifiers":[],"name":"acquisition-reason","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.acquisition-reason","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":185,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-acquisition-reason"},{"apiScope":"exported","doc":{"body":"Listing argv without -F; execute only for listing mode through a guarded reader.","summary":"Listing argv without -F; execute only for listing mode through a guarded reader."},"id":"LibTmux::Query::Plan::Plan.candidate-command","kind":"property","modifiers":[],"name":"candidate-command","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.candidate-command","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":191,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Invocation:D","slug":"libtmux-query-plan-plan-candidate-command"},{"apiScope":"exported","doc":{"body":"Refuse altered prepared values; compile again to preserve evidence bindings.","summary":"Refuse altered prepared values; compile again to preserve evidence bindings."},"id":"LibTmux::Query::Plan::Plan.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":202,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan-clone"},{"apiScope":"exported","doc":{"body":"Compile without I/O. require refuses any residual source work before acquisition.","summary":"Compile without I/O. require refuses any residual source work before acquisition."},"id":"LibTmux::Query::Plan::Plan.compile","kind":"method","modifiers":[],"name":"compile","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.compile","signatures":[{"params":[{"keywordOnly":false,"name":"$filter","optional":false,"type":"Mu"},{"keywordOnly":true,"name":"$capabilities","optional":false,"type":"Mu"},{"default":"'auto'","keywordOnly":true,"name":"$pushdown","optional":true,"type":"Mu"},{"default":"4096","keywordOnly":true,"name":"$max-filter-bytes","optional":true,"type":"Mu"}],"raw":"method compile(Mu $filter, Mu :$capabilities!,\n                   Mu :$pushdown = 'auto', Mu :$max-filter-bytes = 4096 --> Plan:D)","references":[{"end":129,"start":123,"target":"LibTmux::Query::Plan::Plan"}],"returns":"Plan:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"compile","declaration":true},{"text":"(Mu $filter, Mu :$capabilities!,\n                   Mu :$pushdown = 'auto', Mu :$max-filter-bytes = 4096 --> "},{"text":"Plan:D","target":"LibTmux::Query::Plan::Plan"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":205,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan-compile"},{"apiScope":"exported","doc":{"body":"Candidate filtering must never supply an incomplete child set to relation predicates.","summary":"Candidate filtering must never supply an incomplete child set to relation predicates."},"id":"LibTmux::Query::Plan::Plan.complete-graph-required","kind":"method","modifiers":[],"name":"complete-graph-required","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.complete-graph-required","signatures":[{"params":[],"raw":"method complete-graph-required(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":30,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"complete-graph-required","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":255,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan-complete-graph-required"},{"apiScope":"exported","doc":{"body":"Root entity schema; empty results retain this type contract.","summary":"Root entity schema; empty results retain this type contract."},"id":"LibTmux::Query::Plan::Plan.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.entity","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":175,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-entity"},{"apiScope":"exported","doc":{"body":"Original validated predicate, retained for every local result check.","summary":"Original validated predicate, retained for every local result check."},"id":"LibTmux::Query::Plan::Plan.filter","kind":"property","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.filter","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":173,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Filter:D","slug":"libtmux-query-plan-plan-filter"},{"apiScope":"exported","doc":{"body":"Whether the complete predicate has an enabled exact source implementation.","summary":"Whether the complete predicate has an enabled exact source implementation."},"id":"LibTmux::Query::Plan::Plan.fully-pushed","kind":"property","modifiers":[],"name":"fully-pushed","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.fully-pushed","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":179,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-query-plan-plan-fully-pushed"},{"apiScope":"exported","doc":{"body":"Identity rule for contextual rows: scoped-id, session-index or scoped-record.","summary":"Identity rule for contextual rows: scoped-id, session-index or scoped-record."},"id":"LibTmux::Query::Plan::Plan.identity-normalization","kind":"property","modifiers":[],"name":"identity-normalization","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.identity-normalization","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":187,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-identity-normalization"},{"apiScope":"exported","doc":{"body":"Recheck the original validated predicate locally on a fully acquired candidate.","summary":"Recheck the original validated predicate locally on a fully acquired candidate."},"id":"LibTmux::Query::Plan::Plan.matches","kind":"method","modifiers":[],"name":"matches","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.matches","signatures":[{"params":[{"keywordOnly":false,"name":"$view","optional":false}],"raw":"method matches($view --> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"matches","declaration":true},{"text":"($view --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":257,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan-matches"},{"apiScope":"exported","doc":{"body":"Refuse unchecked construction; compile a validated filter with capabilities.","summary":"Refuse unchecked construction; compile a validated filter with capabilities."},"id":"LibTmux::Query::Plan::Plan.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.new","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method new(|)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":200,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-query-plan-plan-new"},{"apiScope":"exported","doc":{"body":"Immutable root-field decoding schema bound to the observed daemon identity.","summary":"Immutable root-field decoding schema bound to the observed daemon identity."},"id":"LibTmux::Query::Plan::Plan.projection","kind":"property","modifiers":[],"name":"projection","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.projection","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":189,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Projection:D","slug":"libtmux-query-plan-plan-projection"},{"apiScope":"exported","doc":{"body":"Requested source policy: auto, never or require.","summary":"Requested source policy: auto, never or require."},"id":"LibTmux::Query::Plan::Plan.pushdown","kind":"property","modifiers":[],"name":"pushdown","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.pushdown","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":177,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-pushdown"},{"apiScope":"exported","doc":{"body":"Captured field requirements, including fields reached through relationships.","summary":"Captured field requirements, including fields reached through relationships."},"id":"LibTmux::Query::Plan::Plan.required-fields","kind":"property","modifiers":[],"name":"required-fields","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.required-fields","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":195,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-query-plan-plan-required-fields"},{"apiScope":"exported","doc":{"body":"Complete relationship paths needed by the original local predicate.","summary":"Complete relationship paths needed by the original local predicate."},"id":"LibTmux::Query::Plan::Plan.required-relations","kind":"property","modifiers":[],"name":"required-relations","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.required-relations","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":197,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"List:D","slug":"libtmux-query-plan-plan-required-relations"},{"apiScope":"exported","doc":{"body":"Actual candidate FORMAT restriction, or empty when source work is deferred.","summary":"Actual candidate FORMAT restriction, or empty when source work is deferred."},"id":"LibTmux::Query::Plan::Plan.source-filter","kind":"property","modifiers":[],"name":"source-filter","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.source-filter","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":181,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"libtmux-query-plan-plan-source-filter"},{"apiScope":"exported","doc":{"body":"Translation tree with paths, exactness, expressions and local-work reasons.","summary":"Translation tree with paths, exactness, expressions and local-work reasons."},"id":"LibTmux::Query::Plan::Plan.steps","kind":"property","modifiers":[],"name":"steps","package":"LibTmux","parent":"LibTmux::Query::Plan::Plan","product":"core","publicId":"LibTmux::Query::Plan::Plan.steps","signatures":[],"source":{"file":"lib/LibTmux/Query/Plan.rakumod","line":193,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Step:D","slug":"libtmux-query-plan-plan-steps"},{"apiScope":"exported","doc":{"body":"# Captured selections\n\nA concrete selection consumes ` Selection[Pane, 'pane'] ` or another catalogue\nentity schema. ` new(:items) ` copies finite, eager, defined membership. It does\nnot deep-clone member objects. Observation classes must supply their own\nread-only field contract.\n\nBinding ` my @panes := $snapshot.panes ` preserves the selection. Array\nassignment materializes ordinary array membership; assigning to a scalar\nitemizes the selection. Use ` $panes.List ` when explicit list traversal is\nwanted. Each iterator and Seq is fresh. Array conversion is independently\nmutable; List membership cannot be replaced.\n\n` where ` accepts criterion data or a compiled Filter and validates the schema\nbefore traversal. ` filter ` invokes one callback per member, eagerly in source\norder, and throws a directly returned Failure before Boolean coercion. Both\nreturn the same concrete selection type and preserve order and duplicates.\nNative ` grep `, ` map `, ` sort `, ` first ` and junctions delegate to the captured\nList, including grep adverbs. They retain native return and evaluation rules.\n` one ` constructs a junction; exact cardinality uses ` single `.","summary":""},"id":"LibTmux::Selection","kind":"module","modifiers":[],"name":"Selection","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Selection","signatures":[],"source":{"file":"lib/LibTmux/Selection.rakumod","line":2,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection"},{"apiScope":"exported","doc":{"body":"Eager captured membership; transformations perform no acquisition or commands.","summary":"Eager captured membership; transformations perform no acquisition or commands."},"id":"LibTmux::Selection::Selection","kind":"trait","modifiers":[],"name":"Selection","package":"LibTmux","parent":"LibTmux::Selection","product":"core","publicId":"LibTmux::Selection::Selection","signatures":[],"source":{"file":"lib/LibTmux/Selection.rakumod","line":8,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection"},{"apiScope":"exported","doc":{"body":"Delegate positional lookup to captured membership with native Raku indexing behavior.","summary":"Delegate positional lookup to captured membership with native Raku indexing behavior."},"id":"LibTmux::Selection::Selection.AT-POS","kind":"method","modifiers":[],"name":"AT-POS","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.AT-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method AT-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"AT-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":35,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-at-pos"},{"apiScope":"exported","doc":{"body":"Materialize an independent mutable membership array; contained views remain shared.","summary":"Materialize an independent mutable membership array; contained views remain shared."},"id":"LibTmux::Selection::Selection.Array","kind":"method","modifiers":[],"name":"Array","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.Array","signatures":[{"params":[],"raw":"method Array(--> Array:D)","references":[],"returns":"Array:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Array","declaration":true},{"text":"(--> Array:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":47,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-array"},{"apiScope":"exported","doc":{"body":"True when captured membership is nonempty.","summary":"True when captured membership is nonempty."},"id":"LibTmux::Selection::Selection.Bool","kind":"method","modifiers":[],"name":"Bool","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.Bool","signatures":[{"params":[],"raw":"method Bool(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Bool","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-bool"},{"apiScope":"exported","doc":{"body":"Check an index locally without acquiring or refreshing data.","summary":"Check an index locally without acquiring or refreshing data."},"id":"LibTmux::Selection::Selection.EXISTS-POS","kind":"method","modifiers":[],"name":"EXISTS-POS","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.EXISTS-POS","signatures":[{"params":[{"keywordOnly":false,"name":"$index","optional":false}],"raw":"method EXISTS-POS($index)","references":[],"nativeSyntax":[{"start":7,"end":17,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"EXISTS-POS","declaration":true},{"text":"($index)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":37,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-exists-pos"},{"apiScope":"exported","doc":{"body":"Return captured membership without writable element containers.","summary":"Return captured membership without writable element containers."},"id":"LibTmux::Selection::Selection.List","kind":"method","modifiers":[],"name":"List","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.List","signatures":[{"params":[],"raw":"method List(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"List","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":45,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-list-q6ut"},{"apiScope":"exported","doc":{"body":"Return a fresh native sequence over captured membership.","summary":"Return a fresh native sequence over captured membership."},"id":"LibTmux::Selection::Selection.Seq","kind":"method","modifiers":[],"name":"Seq","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.Seq","signatures":[{"params":[],"raw":"method Seq(--> Seq:D)","references":[],"returns":"Seq:D","nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"Seq","declaration":true},{"text":"(--> Seq:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":49,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-seq"},{"apiScope":"exported","doc":{"body":"Construct the native all junction over captured membership.","summary":"Construct the native all junction over captured membership."},"id":"LibTmux::Selection::Selection.all","kind":"method","modifiers":[],"name":"all","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.all","signatures":[{"params":[],"raw":"method all()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"all","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":63,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-all"},{"apiScope":"exported","doc":{"body":"Construct the native any junction over captured membership.","summary":"Construct the native any junction over captured membership."},"id":"LibTmux::Selection::Selection.any","kind":"method","modifiers":[],"name":"any","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.any","signatures":[{"params":[],"raw":"method any()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"any","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":61,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-any"},{"apiScope":"exported","doc":{"body":"Revalidate and copy membership when cloning a concrete selection.","summary":"Revalidate and copy membership when cloning a concrete selection."},"id":"LibTmux::Selection::Selection.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.clone","signatures":[{"params":[{"default":"$!members","keywordOnly":true,"name":"$items","optional":true,"type":"Mu"}],"raw":"method clone(Mu :$items = $!members)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(Mu :$items = $!members)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":28,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-clone"},{"apiScope":"exported","doc":{"body":"Return the exact captured membership count.","summary":"Return the exact captured membership count."},"id":"LibTmux::Selection::Selection.elems","kind":"method","modifiers":[],"name":"elems","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.elems","signatures":[{"params":[],"raw":"method elems(--> Int:D)","references":[],"returns":"Int:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"elems","declaration":true},{"text":"(--> Int:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":39,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-elems"},{"apiScope":"exported","doc":{"body":"Entity schema retained even by an empty selection.","summary":"Entity schema retained even by an empty selection."},"id":"LibTmux::Selection::Selection.entity","kind":"method","modifiers":[],"name":"entity","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.entity","signatures":[{"params":[],"raw":"method entity(--> Str:D)","references":[],"returns":"Str:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"entity","declaration":true},{"text":"(--> Str:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-entity"},{"apiScope":"exported","doc":{"body":"Run a callback once per member in order and preserve this concrete selection type.","summary":"Run a callback once per member in order and preserve this concrete selection type."},"id":"LibTmux::Selection::Selection.filter","kind":"method","modifiers":[],"name":"filter","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.filter","signatures":[{"params":[{"keywordOnly":false,"name":"&predicate","optional":false}],"raw":"method filter(&predicate)","references":[],"nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"filter","declaration":true},{"text":"(&predicate)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-filter"},{"apiScope":"exported","doc":{"body":"Use native first-match behavior, including native absence semantics.","summary":"Use native first-match behavior, including native absence semantics."},"id":"LibTmux::Selection::Selection.first","kind":"method","modifiers":[],"name":"first","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.first","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method first(|capture)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"first","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":57,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-first"},{"apiScope":"exported","doc":{"body":"Use native matching and adverbs, returning a Seq rather than another selection.","summary":"Use native matching and adverbs, returning a Seq rather than another selection."},"id":"LibTmux::Selection::Selection.grep","kind":"method","modifiers":[],"name":"grep","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.grep","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method grep(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"grep","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":51,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-grep"},{"apiScope":"exported","doc":{"body":"Return a fresh iterator over captured eager membership.","summary":"Return a fresh iterator over captured eager membership."},"id":"LibTmux::Selection::Selection.iterator","kind":"method","modifiers":[],"name":"iterator","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.iterator","signatures":[{"params":[],"raw":"method iterator()","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"iterator","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-iterator"},{"apiScope":"exported","doc":{"body":"Return eager replayable membership with native list semantics.","summary":"Return eager replayable membership with native list semantics."},"id":"LibTmux::Selection::Selection.list","kind":"method","modifiers":[],"name":"list","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.list","signatures":[{"params":[],"raw":"method list(--> List:D)","references":[],"returns":"List:D","nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"list","declaration":true},{"text":"(--> List:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":43,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-list-1iqf"},{"apiScope":"exported","doc":{"body":"Use native mapping; projections may change element type.","summary":"Use native mapping; projections may change element type."},"id":"LibTmux::Selection::Selection.map","kind":"method","modifiers":[],"name":"map","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.map","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method map(|capture)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"map","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":53,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-map"},{"apiScope":"exported","doc":{"body":"Construct the native none junction over captured membership.","summary":"Construct the native none junction over captured membership."},"id":"LibTmux::Selection::Selection.none","kind":"method","modifiers":[],"name":"none","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.none","signatures":[{"params":[],"raw":"method none()","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"none","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":65,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-none"},{"apiScope":"exported","doc":{"body":"Construct the native one junction; this is not exact-cardinality retrieval.","summary":"Construct the native one junction; this is not exact-cardinality retrieval."},"id":"LibTmux::Selection::Selection.one","kind":"method","modifiers":[],"name":"one","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.one","signatures":[{"params":[],"raw":"method one()","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"one","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":59,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-one"},{"apiScope":"exported","doc":{"body":"Return exactly one member or throw its observed cardinality.","summary":"Return exactly one member or throw its observed cardinality."},"id":"LibTmux::Selection::Selection.single","kind":"method","modifiers":[],"name":"single","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.single","signatures":[{"params":[],"raw":"method single(--> T:D)","references":[],"returns":"T:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single","declaration":true},{"text":"(--> T:D)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":88,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-single"},{"apiScope":"exported","doc":{"body":"Return Nil for zero members, the sole member for one, otherwise throw.","summary":"Return Nil for zero members, the sole member for one, otherwise throw."},"id":"LibTmux::Selection::Selection.single-or-nil","kind":"method","modifiers":[],"name":"single-or-nil","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.single-or-nil","signatures":[{"params":[],"raw":"method single-or-nil()","references":[],"nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"single-or-nil","declaration":true},{"text":"()"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-single-or-nil"},{"apiScope":"exported","doc":{"body":"Use native sorting and return its ordinary Raku result.","summary":"Use native sorting and return its ordinary Raku result."},"id":"LibTmux::Selection::Selection.sort","kind":"method","modifiers":[],"name":"sort","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.sort","signatures":[{"params":[{"keywordOnly":false,"name":"capture","optional":false}],"raw":"method sort(|capture)","references":[],"nativeSyntax":[{"start":7,"end":11,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"sort","declaration":true},{"text":"(|capture)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":55,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-sort"},{"apiScope":"exported","doc":{"body":"Compile criteria before traversal, including on an empty selection.","summary":"Compile criteria before traversal, including on an empty selection."},"id":"LibTmux::Selection::Selection.where","kind":"method","modifiers":[],"name":"where","package":"LibTmux","parent":"LibTmux::Selection::Selection","product":"core","publicId":"LibTmux::Selection::Selection.where","signatures":[{"params":[{"keywordOnly":false,"name":"$criteria","optional":false,"type":"Mu"}],"raw":"method where(Mu $criteria)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"where","declaration":true},{"text":"(Mu $criteria)"}]}],"source":{"file":"lib/LibTmux/Selection.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-selection-selection-where"},{"apiScope":"exported","doc":{"body":"# Server ownership\n\n` new ` captures a borrowed endpoint without I/O. ` snapshot ` and ` capabilities `\nacquire daemon state explicitly. ` new-session ` requires an existing daemon,\ncreates a detached session, and returns a SessionRef from tmux's returned ID.\nNames are literal Unicode text; controls, backslash, dot and colon are refused\nbefore creation because supported tmux releases normalize them differently.\nA shell-command explicitly requests tmux's shell-command interpretation.\n\n` start ` creates a clean foreground daemon on an exclusive temporary socket,\nverifies its executable profile before launch, binds its actual process identity,\nand creates the initial session. The startup timeout covers all stages. Linux\ninotify socket attributes signal listener readiness; pidfds bind termination to\nthe original process, independently of socket reuse.\n\nClose is idempotent and joins owned work. Borrowed daemons remain running.\nOwned daemons receive TERM followed by bounded KILL escalation and are reaped.\nCleanup removes only the original socket and empty original directory; unknown\nfiles and replacement sockets are preserved. References retain values only and\nare not clients owned by the Server. A stopped owned daemon invalidates them.\n\nConfiguration factories perform one explicit identity observation. The returned\nfacades retain endpoint and incarnation values, and each subsequent configuration\noperation owns its temporary command client. ` open-control ` and ` attach ` return\nseparate lifecycle owners: callers must close them. Closing a borrowed Server\ndoes not close those owners; closing an owned daemon causes its attached clients\nto disconnect. ` attach ` proves process creation, not terminal readiness.\n\n` command ` is an explicit tmux-syntax escape hatch with a daemon fence. It does\nnot insert an entity target or interpret shell syntax on the caller's behalf.\n` run-batch ` reports partial outcomes and never promises rollback.\n\n\n\n# Explicit environment and health\n\n` from-env ` is the only factory that interprets ` TMUX `. It parses its final\nPID and session components from the right, so commas in the socket path remain\nliteral. It requires an absolute socket path, validates ` TMUX_PANE ` when\npresent, observes the actual daemon and rejects a different PID. The returned\nborrowed facade is bound to that incarnation. Child processes still receive\nneither ambient variable. Imported object IDs are observations from the supplied\nenvironment, not evidence that those objects still exist:\n\nuse LibTmux;\nmy $server = LibTmux::Server.from-env(:environment(%*ENV));\nLEAVE $server.close;\nmy $snapshot = $server.snapshot;\nmy $pane = $snapshot.panes.where(%(id => $server.environment-pane-id)).single;\nmy $window = $pane.window;\nmy $session = $snapshot.sessions\n    .where(%(id => $server.environment-session-id)).single;\n\nThe selection throws for a vanished object or absent imported ID. A window can\nbelong to several sessions; the imported session ID supplies that context.\n` capabilities ` is the explicit native health observation: success returns\nverified daemon evidence, while connection, identity and permission failures\nretain their original typed exceptions. ` has-session(:name) ` and\n` has-session(:id) ` return false only after a successful exact listing finds\nno match. ` kill-server ` deliberately terminates the observed daemon, including\na borrowed one; ` close ` continues to preserve borrowed daemons. An owner must\nstill close after kill-server to join its process and filesystem cleanup.\n\n\n\n# Jobs and channels\n\n` run-shell ` receives literal shell source; tmux FORMAT-looking text is escaped\nbefore dispatch. ` if-shell ` follows the same rule for its shell condition and\naccepts bounded Invocation values for both branches. Its explicit ` :format `\noption instead evaluates a native tmux FORMAT condition. ` source-file ` reads\none literal pathname, escaping native glob metacharacters; it does not expand\nFORMAT, tilde or a caller shell. Relative paths use the captured command cwd.\n` :parse-only ` parses configuration without executing it.\n\nEach request shares one admission, observation and dispatch deadline. A\nbackground job acknowledges scheduling. Foreground completion follows tmux's\njob/command queue contract, not an application-specific postcondition; command\noutput availability also depends on the declared daemon profile. Timing out or\ncancelling a client does not undo a job, configuration effect or channel lock\nalready accepted by the daemon. ` wait-for ` offers only wait, signal, lock and\nunlock; it does not claim that a signal proves another process's application\nwork completed.\n\n\n\n# Administrative commands\n\nDiagnostics and administrative commands intentionally use the explicit bounded\nInvocation surface rather than separate wrappers. These complete calls retain\nraw stdout/stderr in Result, enforce the server deadline and throw typed command\nerrors. ` list-commands `, ` show-messages `, ` lock-server ` and ` server-access `\nare deliberate replacements for named Python helpers, not claims of identical\ntyped parameters. ` switch-mode ` is also available through Invocation.\n\nuse LibTmux;\nmy $server = LibTmux::Server.start(:name<inspection>);\nLEAVE $server.close;\nmy $commands = $server.command(Invocation.new(:argv(['list-commands'])));\nmy $access = $server.command(Invocation.new(:argv(['server-access', '-l'])));\nmy $messages = $server.command(Invocation.new(:argv(['show-messages', '-T'])));\n$server.command(Invocation.new(:argv(['lock-server'])));\n\nAdministrative flags keep tmux's native semantics and errors; arbitrary\nInvocation values do not acquire a typed catalogue guarantee. Locking may run\nconfigured lock commands on attached clients. Access changes affect other users.\nUse only an endpoint whose administration the caller owns or has authorized.\nTo detach captured clients, iterate ` $snapshot.clients ` and call each\n` .ref.detach `. Each target is identity guarded; a changing client set is not\nan atomic detach-all operation, and acknowledgement does not prove terminal\nrendering or child-process exit.","summary":""},"id":"LibTmux::Server","kind":"class","modifiers":[],"name":"Server","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Server","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server"},{"apiScope":"exported","doc":{"body":"Spawn a separately owned interactive client on the caller's explicit terminal.","summary":"Spawn a separately owned interactive client on the caller's explicit terminal."},"id":"LibTmux::Server.attach","kind":"method","modifiers":[],"name":"attach","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.attach","signatures":[{"params":[{"keywordOnly":true,"name":"$session","optional":false,"type":"SessionId:D"},{"keywordOnly":true,"name":"$terminal","optional":false,"type":"IO::Handle:D"},{"keywordOnly":false,"name":"%settings","optional":false}],"raw":"method attach(SessionId:D :$session!, IO::Handle:D :$terminal!, *%settings --> LibTmux::Attachment:D)","references":[{"end":25,"start":14,"target":"LibTmux::Types::SessionId"},{"end":100,"start":79,"target":"LibTmux::Attachment"}],"returns":"LibTmux::Attachment:D","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"attach","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" :$session!, IO::Handle:D :$terminal!, *%settings --> "},{"text":"LibTmux::Attachment:D","target":"LibTmux::Attachment"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":591,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-attach"},{"apiScope":"exported","doc":{"body":"Resolve a separately owned terminal client; process creation is not attachment proof.","summary":"Resolve a separately owned terminal client; process creation is not attachment proof."},"id":"LibTmux::Server.attach-async","kind":"method","modifiers":[],"name":"attach-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.attach-async","signatures":[{"params":[{"keywordOnly":true,"name":"$session","optional":false,"type":"SessionId:D"},{"keywordOnly":true,"name":"$terminal","optional":false,"type":"IO::Handle:D"},{"default":"False","keywordOnly":true,"name":"$read-only","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$detach-others","optional":true,"type":"Bool:D"},{"default":"False","keywordOnly":true,"name":"$update-environment","optional":true,"type":"Bool:D"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method attach-async(SessionId:D :$session!, IO::Handle:D :$terminal!,\n                    Bool:D :$read-only = False, Bool:D :$detach-others = False,\n                    Bool:D :$update-environment = False,\n                    Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":31,"start":20,"target":"LibTmux::Types::SessionId"},{"end":239,"start":227,"target":"LibTmux::Transport::Cancellation"},{"end":263,"start":251,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"attach-async","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" :$session!, IO::Handle:D :$terminal!,\n                    Bool:D :$read-only = False, Bool:D :$detach-others = False,\n                    Bool:D :$update-environment = False,\n                    "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":595,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-attach-async"},{"apiScope":"exported","doc":{"body":"Observe daemon identity and return its named binary-buffer facade.","summary":"Observe daemon identity and return its named binary-buffer facade."},"id":"LibTmux::Server.buffers","kind":"method","modifiers":[],"name":"buffers","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.buffers","signatures":[{"params":[],"raw":"method buffers(--> LibTmux::Configuration::Buffers:D)","references":[{"end":52,"start":19,"target":"LibTmux::Configuration::Buffers"}],"returns":"LibTmux::Configuration::Buffers:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"buffers","declaration":true},{"text":"(--> "},{"text":"LibTmux::Configuration::Buffers:D","target":"LibTmux::Configuration::Buffers"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":561,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-buffers"},{"apiScope":"exported","doc":{"body":"Observe the daemon's capabilities explicitly; this performs tmux I/O.","summary":"Observe the daemon's capabilities explicitly; this performs tmux I/O."},"id":"LibTmux::Server.capabilities","kind":"method","modifiers":[],"name":"capabilities","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.capabilities","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method capabilities(Cancellation :$cancel = Cancellation --> LibTmux::Capabilities:D)","references":[{"end":32,"start":20,"target":"LibTmux::Transport::Cancellation"},{"end":56,"start":44,"target":"LibTmux::Transport::Cancellation"},{"end":84,"start":61,"target":"LibTmux::Capabilities"}],"returns":"LibTmux::Capabilities:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capabilities","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"LibTmux::Capabilities:D","target":"LibTmux::Capabilities"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":383,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-capabilities"},{"apiScope":"exported","doc":{"body":"Resolve to one fresh immutable daemon capability observation.","summary":"Resolve to one fresh immutable daemon capability observation."},"id":"LibTmux::Server.capabilities-async","kind":"method","modifiers":[],"name":"capabilities-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.capabilities-async","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method capabilities-async(Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":38,"start":26,"target":"LibTmux::Transport::Cancellation"},{"end":62,"start":50,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":25,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"capabilities-async","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":387,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-capabilities-async"},{"apiScope":"exported","doc":{"body":"Refuse cloning of runtime admission and daemon ownership state.","summary":"Refuse cloning of runtime admission and daemon ownership state."},"id":"LibTmux::Server.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":345,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-clone"},{"apiScope":"exported","doc":{"body":"Join idempotent shutdown; borrowed daemons remain running.","summary":"Join idempotent shutdown; borrowed daemons remain running."},"id":"LibTmux::Server.close","kind":"method","modifiers":[],"name":"close","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.close","signatures":[{"params":[],"raw":"method close(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":685,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-close"},{"apiScope":"exported","doc":{"body":"Join admitted work; owned servers additionally terminate and reap their original daemon.","summary":"Join admitted work; owned servers additionally terminate and reap their original daemon."},"id":"LibTmux::Server.close-async","kind":"method","modifiers":[],"name":"close-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.close-async","signatures":[{"params":[],"raw":"method close-async(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"close-async","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":687,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-close-async"},{"apiScope":"exported","doc":{"body":"Execute explicit tmux command syntax in the currently observed daemon.","summary":"Execute explicit tmux command syntax in the currently observed daemon."},"id":"LibTmux::Server.command","kind":"method","modifiers":[],"name":"command","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.command","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method command(Invocation:D $command, *%options --> Result:D)","references":[{"end":27,"start":15,"target":"LibTmux::Command::Invocation"},{"end":60,"start":52,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, *%options --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":460,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-command"},{"apiScope":"exported","doc":{"body":"Copy input before scheduling one guarded command; retain exit status and raw streams.","summary":"Copy input before scheduling one guarded command; retain exit status and raw streams."},"id":"LibTmux::Server.command-async","kind":"method","modifiers":[],"name":"command-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.command-async","signatures":[{"params":[{"keywordOnly":false,"name":"$command","optional":false,"type":"Invocation:D"},{"default":"Blob.new","keywordOnly":true,"name":"$stdin","optional":true,"type":"Blob:D"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"},{"default":"True","keywordOnly":true,"name":"$check","optional":true,"type":"Bool:D"}],"raw":"method command-async(Invocation:D $command, Blob:D :$stdin = Blob.new,\n                     Cancellation :$cancel = Cancellation, Bool:D :$check = True --> Promise:D)","references":[{"end":33,"start":21,"target":"LibTmux::Command::Invocation"},{"end":104,"start":92,"target":"LibTmux::Transport::Cancellation"},{"end":128,"start":116,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"command-async","declaration":true},{"text":"("},{"text":"Invocation:D","target":"LibTmux::Command::Invocation"},{"text":" $command, Blob:D :$stdin = Blob.new,\n                     "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":", Bool:D :$check = True --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":464,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-command-async"},{"apiScope":"exported","doc":{"body":"Captured connection settings; retaining them owns no process.","summary":"Captured connection settings; retaining them owns no process."},"id":"LibTmux::Server.endpoint","kind":"property","modifiers":[],"name":"endpoint","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.endpoint","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":261,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Endpoint:D","slug":"libtmux-server-endpoint"},{"apiScope":"exported","doc":{"body":"Observe daemon identity and return its global environment facade.","summary":"Observe daemon identity and return its global environment facade."},"id":"LibTmux::Server.environment","kind":"method","modifiers":[],"name":"environment","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.environment","signatures":[{"params":[],"raw":"method environment(--> LibTmux::Configuration::Environment:D)","references":[{"end":60,"start":23,"target":"LibTmux::Configuration::Environment"}],"returns":"LibTmux::Configuration::Environment:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"environment","declaration":true},{"text":"(--> "},{"text":"LibTmux::Configuration::Environment:D","target":"LibTmux::Configuration::Environment"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":557,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-environment"},{"apiScope":"exported","doc":{"body":"Pane ID explicitly imported from TMUX_PANE; undefined for ordinary construction.","summary":"Pane ID explicitly imported from TMUX_PANE; undefined for ordinary construction."},"id":"LibTmux::Server.environment-pane-id","kind":"property","modifiers":[],"name":"environment-pane-id","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.environment-pane-id","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":270,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"PaneId","slug":"libtmux-server-environment-pane-id"},{"apiScope":"exported","doc":{"body":"Session ID explicitly imported from TMUX; undefined when tmux supplied -1.","summary":"Session ID explicitly imported from TMUX; undefined when tmux supplied -1."},"id":"LibTmux::Server.environment-session-id","kind":"property","modifiers":[],"name":"environment-session-id","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.environment-session-id","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":272,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SessionId","slug":"libtmux-server-environment-session-id"},{"apiScope":"exported","doc":{"body":"Observe capabilities and explain an explicit source query without executing its listing.","summary":"Observe capabilities and explain an explicit source query without executing its listing."},"id":"LibTmux::Server.explain","kind":"method","modifiers":[],"name":"explain","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.explain","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"default":"Map.new","keywordOnly":true,"name":"$where","optional":true,"type":"Mu"},{"default":"'auto'","keywordOnly":true,"name":"$pushdown","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method explain(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto', *%unknown --> Plan:D)","references":[{"end":93,"start":87,"target":"LibTmux::Query::Plan::Plan"}],"returns":"Plan:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"explain","declaration":true},{"text":"(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto', *%unknown --> "},{"text":"Plan:D","target":"LibTmux::Query::Plan::Plan"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":392,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-explain"},{"apiScope":"exported","doc":{"body":"Explain pane acquisition, pushed restrictions and residual local work.","summary":"Explain pane acquisition, pushed restrictions and residual local work."},"id":"LibTmux::Server.explain-panes","kind":"method","modifiers":[],"name":"explain-panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.explain-panes","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method explain-panes(*%options --> Plan:D)","references":[{"end":41,"start":35,"target":"LibTmux::Query::Plan::Plan"}],"returns":"Plan:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"explain-panes","declaration":true},{"text":"(*%options --> "},{"text":"Plan:D","target":"LibTmux::Query::Plan::Plan"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":432,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-explain-panes"},{"apiScope":"exported","doc":{"body":"Import an explicit TMUX environment, verify its daemon PID and bind that incarnation.","summary":"Import an explicit TMUX environment, verify its daemon PID and bind that incarnation."},"id":"LibTmux::Server.from-env","kind":"method","modifiers":[],"name":"from-env","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.from-env","signatures":[{"params":[{"default":"%*ENV","keywordOnly":true,"name":"$environment","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%settings","optional":false}],"raw":"method from-env(Mu :$environment = %*ENV, *%settings)","references":[],"nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"from-env","declaration":true},{"text":"(Mu :$environment = %*ENV, *%settings)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":302,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-from-env"},{"apiScope":"exported","doc":{"body":"Test one exact session ID or name. Acquisition and identity failures still throw.","summary":"Test one exact session ID or name. Acquisition and identity failures still throw."},"id":"LibTmux::Server.has-session","kind":"method","modifiers":[],"name":"has-session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.has-session","signatures":[{"params":[{"default":"SessionId","keywordOnly":true,"name":"$id","optional":true,"type":"Mu"},{"default":"Str","keywordOnly":true,"name":"$name","optional":true,"type":"Mu"}],"raw":"method has-session(Mu :$id = SessionId, Mu :$name = Str --> Bool:D)","references":[{"end":38,"start":29,"target":"LibTmux::Types::SessionId"}],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"has-session","declaration":true},{"text":"(Mu :$id = "},{"text":"SessionId","target":"LibTmux::Types::SessionId"},{"text":", Mu :$name = Str --> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":440,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-has-session"},{"apiScope":"exported","doc":{"body":"Observe daemon identity and return global session/window hooks.","summary":"Observe daemon identity and return global session/window hooks."},"id":"LibTmux::Server.hooks","kind":"method","modifiers":[],"name":"hooks","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.hooks","signatures":[{"params":[{"default":"'session'","keywordOnly":true,"name":"$scope","optional":true,"type":"Str:D"}],"raw":"method hooks(Str:D :$scope = 'session' --> LibTmux::Configuration::Hooks:D)","references":[{"end":74,"start":43,"target":"LibTmux::Configuration::Hooks"}],"returns":"LibTmux::Configuration::Hooks:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"hooks","declaration":true},{"text":"(Str:D :$scope = 'session' --> "},{"text":"LibTmux::Configuration::Hooks:D","target":"LibTmux::Configuration::Hooks"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":565,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-hooks"},{"apiScope":"exported","doc":{"body":"Execute one of two bounded commands after a shell test, or an explicit FORMAT condition.","summary":"Execute one of two bounded commands after a shell test, or an explicit FORMAT condition."},"id":"LibTmux::Server.if-shell","kind":"method","modifiers":[],"name":"if-shell","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.if-shell","signatures":[{"params":[{"keywordOnly":false,"name":"$condition","optional":false,"type":"Mu"},{"keywordOnly":false,"name":"$then","optional":false,"type":"Mu"},{"default":"Invocation","keywordOnly":true,"name":"$otherwise","optional":true,"type":"Mu"},{"default":"False","keywordOnly":true,"name":"$format","optional":true,"type":"Mu"},{"default":"False","keywordOnly":true,"name":"$background","optional":true,"type":"Mu"},{"default":"PaneId","keywordOnly":true,"name":"$pane","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method if-shell(Mu $condition, Mu $then, Mu :$otherwise = Invocation,\n                Mu :$format = False, Mu :$background = False, Mu :$pane = PaneId,\n                Cancellation :$cancel = Cancellation --> Result:D)","references":[{"end":68,"start":58,"target":"LibTmux::Command::Invocation"},{"end":150,"start":144,"target":"LibTmux::Types::PaneId"},{"end":180,"start":168,"target":"LibTmux::Transport::Cancellation"},{"end":204,"start":192,"target":"LibTmux::Transport::Cancellation"},{"end":217,"start":209,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"if-shell","declaration":true},{"text":"(Mu $condition, Mu $then, Mu :$otherwise = "},{"text":"Invocation","target":"LibTmux::Command::Invocation"},{"text":",\n                Mu :$format = False, Mu :$background = False, Mu :$pane = "},{"text":"PaneId","target":"LibTmux::Types::PaneId"},{"text":",\n                "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":495,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-if-shell"},{"apiScope":"exported","doc":{"body":"Observe daemon identity and return its key-binding facade.","summary":"Observe daemon identity and return its key-binding facade."},"id":"LibTmux::Server.key-bindings","kind":"method","modifiers":[],"name":"key-bindings","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.key-bindings","signatures":[{"params":[],"raw":"method key-bindings(--> LibTmux::Configuration::KeyBindings:D)","references":[{"end":61,"start":24,"target":"LibTmux::Configuration::KeyBindings"}],"returns":"LibTmux::Configuration::KeyBindings:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"key-bindings","declaration":true},{"text":"(--> "},{"text":"LibTmux::Configuration::KeyBindings:D","target":"LibTmux::Configuration::KeyBindings"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":570,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-key-bindings"},{"apiScope":"exported","doc":{"body":"Explicitly terminate this observed daemon. Owned callers must still close to join cleanup.","summary":"Explicitly terminate this observed daemon. Owned callers must still close to join cleanup."},"id":"LibTmux::Server.kill-server","kind":"method","modifiers":[],"name":"kill-server","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.kill-server","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method kill-server(Cancellation :$cancel = Cancellation --> Result:D)","references":[{"end":31,"start":19,"target":"LibTmux::Transport::Cancellation"},{"end":55,"start":43,"target":"LibTmux::Transport::Cancellation"},{"end":68,"start":60,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"kill-server","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":538,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-kill-server"},{"apiScope":"exported","doc":{"body":"Maximum encoded command size in bytes, including tmux quoting.","summary":"Maximum encoded command size in bytes, including tmux quoting."},"id":"LibTmux::Server.max-command-bytes","kind":"property","modifiers":[],"name":"max-command-bytes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.max-command-bytes","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":265,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-server-max-command-bytes"},{"apiScope":"exported","doc":{"body":"Combined output-byte limit for one owned command response.","summary":"Combined output-byte limit for one owned command response."},"id":"LibTmux::Server.max-output-bytes","kind":"property","modifiers":[],"name":"max-output-bytes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.max-output-bytes","signatures":[],"source":{"file":"lib/LibTmux/Server.rakumod","line":263,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Positive:D","slug":"libtmux-server-max-output-bytes"},{"apiScope":"exported","doc":{"body":"Capture a borrowed endpoint without I/O. Closing it closes clients only.","summary":"Capture a borrowed endpoint without I/O. Closing it closes clients only."},"id":"LibTmux::Server.new","kind":"method","modifiers":[],"name":"new","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.new","signatures":[{"params":[{"default":"'tmux'","keywordOnly":true,"name":"$binary","optional":true},{"default":"''","keywordOnly":true,"name":"$socket-name","optional":true},{"default":"''","keywordOnly":true,"name":"$socket-path","optional":true},{"default":"''","keywordOnly":true,"name":"$config-file","optional":true},{"default":"%*ENV","keywordOnly":true,"name":"$environment","optional":true},{"default":"$*CWD","keywordOnly":true,"name":"$cwd","optional":true},{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true},{"default":"8 * 1024 * 1024","keywordOnly":true,"name":"$max-output-bytes","optional":true},{"default":"12 * 1024","keywordOnly":true,"name":"$max-command-bytes","optional":true}],"raw":"method new(:$binary = 'tmux', :$socket-name = '', :$socket-path = '',\n           :$config-file = '', :$environment = %*ENV, :$cwd = $*CWD,\n           :$timeout-ms = 10_000, :$max-output-bytes = 8 * 1024 * 1024,\n           :$max-command-bytes = 12 * 1024)","references":[],"nativeSyntax":[{"start":7,"end":10,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new","declaration":true},{"text":"(:$binary = 'tmux', :$socket-name = '', :$socket-path = '',\n           :$config-file = '', :$environment = %*ENV, :$cwd = $*CWD,\n           :$timeout-ms = 10_000, :$max-output-bytes = 8 * 1024 * 1024,\n           :$max-command-bytes = 12 * 1024)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":290,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-new"},{"apiScope":"exported","doc":{"body":"Create a detached session and return its value-only, identity-scoped reference.","summary":"Create a detached session and return its value-only, identity-scoped reference."},"id":"LibTmux::Server.new-session","kind":"method","modifiers":[],"name":"new-session","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.new-session","signatures":[{"params":[{"keywordOnly":true,"name":"$name","optional":false},{"default":"Str","keywordOnly":true,"name":"$shell-command","optional":true},{"default":"80","keywordOnly":true,"name":"$width","optional":true},{"default":"24","keywordOnly":true,"name":"$height","optional":true}],"raw":"method new-session(:$name!, :$shell-command = Str, :$width = 80, :$height = 24 --> SessionRef:D)","references":[{"end":95,"start":83,"target":"LibTmux::Model::SessionRef"}],"returns":"SessionRef:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"new-session","declaration":true},{"text":"(:$name!, :$shell-command = Str, :$width = 80, :$height = 24 --> "},{"text":"SessionRef:D","target":"LibTmux::Model::SessionRef"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":452,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-new-session"},{"apiScope":"exported","doc":{"body":"Open a separately owned control connection attached to an explicit session ID.","summary":"Open a separately owned control connection attached to an explicit session ID."},"id":"LibTmux::Server.open-control","kind":"method","modifiers":[],"name":"open-control","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.open-control","signatures":[{"params":[{"keywordOnly":true,"name":"$session-id","optional":false,"type":"SessionId:D"},{"keywordOnly":false,"name":"%settings","optional":false}],"raw":"method open-control(SessionId:D :$session-id!, *%settings --> LibTmux::Control::Connection:D)","references":[{"end":31,"start":20,"target":"LibTmux::Types::SessionId"},{"end":92,"start":62,"target":"LibTmux::Control::Connection"}],"returns":"LibTmux::Control::Connection:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"open-control","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" :$session-id!, *%settings --> "},{"text":"LibTmux::Control::Connection:D","target":"LibTmux::Control::Connection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":575,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-open-control"},{"apiScope":"exported","doc":{"body":"Resolve a separately owned verified control connection; the caller must close it.","summary":"Resolve a separately owned verified control connection; the caller must close it."},"id":"LibTmux::Server.open-control-async","kind":"method","modifiers":[],"name":"open-control-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.open-control-async","signatures":[{"params":[{"keywordOnly":true,"name":"$session-id","optional":false,"type":"SessionId:D"},{"default":"'auto'","keywordOnly":true,"name":"$new-layouts","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method open-control-async(SessionId:D :$session-id!, :$new-layouts = 'auto',\n                          Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":37,"start":26,"target":"LibTmux::Types::SessionId"},{"end":115,"start":103,"target":"LibTmux::Transport::Cancellation"},{"end":139,"start":127,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":25,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"open-control-async","declaration":true},{"text":"("},{"text":"SessionId:D","target":"LibTmux::Types::SessionId"},{"text":" :$session-id!, :$new-layouts = 'auto',\n                          "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":579,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-open-control-async"},{"apiScope":"exported","doc":{"body":"Observe daemon identity and return server options or global session/window defaults.","summary":"Observe daemon identity and return server options or global session/window defaults."},"id":"LibTmux::Server.options","kind":"method","modifiers":[],"name":"options","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.options","signatures":[{"params":[{"default":"'server'","keywordOnly":true,"name":"$scope","optional":true,"type":"Str:D"}],"raw":"method options(Str:D :$scope = 'server' --> LibTmux::Configuration::Options:D)","references":[{"end":77,"start":44,"target":"LibTmux::Configuration::Options"}],"returns":"LibTmux::Configuration::Options:D","nativeSyntax":[{"start":7,"end":14,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"options","declaration":true},{"text":"(Str:D :$scope = 'server' --> "},{"text":"LibTmux::Configuration::Options:D","target":"LibTmux::Configuration::Options"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":551,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-options"},{"apiScope":"exported","doc":{"body":"Whether this facade owns the foreground daemon it started.","summary":"Whether this facade owns the foreground daemon it started."},"id":"LibTmux::Server.owned","kind":"method","modifiers":[],"name":"owned","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.owned","signatures":[{"params":[],"raw":"method owned(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"owned","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":343,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-owned"},{"apiScope":"exported","doc":{"body":"Acquire a typed selection; only requested relationship predicates load the full graph.","summary":"Acquire a typed selection; only requested relationship predicates load the full graph."},"id":"LibTmux::Server.query","kind":"method","modifiers":[],"name":"query","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query(Mu $entity, *%options --> Positional:D)","references":[],"returns":"Positional:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query","declaration":true},{"text":"(Mu $entity, *%options --> Positional:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":404,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query"},{"apiScope":"exported","doc":{"body":"Copy and validate query data before scheduling acquisition within one shared deadline.","summary":"Copy and validate query data before scheduling acquisition within one shared deadline."},"id":"LibTmux::Server.query-async","kind":"method","modifiers":[],"name":"query-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query-async","signatures":[{"params":[{"keywordOnly":false,"name":"$entity","optional":false,"type":"Mu"},{"default":"Map.new","keywordOnly":true,"name":"$where","optional":true,"type":"Mu"},{"default":"'auto'","keywordOnly":true,"name":"$pushdown","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Mu"},{"keywordOnly":false,"name":"%unknown","optional":false}],"raw":"method query-async(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto',\n                   Mu :$cancel = Cancellation, *%unknown --> Promise:D)","references":[{"end":122,"start":110,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-async","declaration":true},{"text":"(Mu $entity, Mu :$where = Map.new, Mu :$pushdown = 'auto',\n                   Mu :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":", *%unknown --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":408,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query-async"},{"apiScope":"exported","doc":{"body":"Acquire panes explicitly; the resulting selection is local and replayable.","summary":"Acquire panes explicitly; the resulting selection is local and replayable."},"id":"LibTmux::Server.query-panes","kind":"method","modifiers":[],"name":"query-panes","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query-panes","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query-panes(*%options --> PaneSelection:D)","references":[{"end":48,"start":33,"target":"LibTmux::Model::PaneSelection"}],"returns":"PaneSelection:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-panes","declaration":true},{"text":"(*%options --> "},{"text":"PaneSelection:D","target":"LibTmux::Model::PaneSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":430,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query-panes"},{"apiScope":"exported","doc":{"body":"Acquire sessions explicitly under the selected pushdown policy.","summary":"Acquire sessions explicitly under the selected pushdown policy."},"id":"LibTmux::Server.query-sessions","kind":"method","modifiers":[],"name":"query-sessions","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query-sessions","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query-sessions(*%options --> SessionSelection:D)","references":[{"end":54,"start":36,"target":"LibTmux::Model::SessionSelection"}],"returns":"SessionSelection:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-sessions","declaration":true},{"text":"(*%options --> "},{"text":"SessionSelection:D","target":"LibTmux::Model::SessionSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":434,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query-sessions"},{"apiScope":"exported","doc":{"body":"Acquire session/index associations without deduplicating repeated window placements.","summary":"Acquire session/index associations without deduplicating repeated window placements."},"id":"LibTmux::Server.query-window-links","kind":"method","modifiers":[],"name":"query-window-links","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query-window-links","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query-window-links(*%options --> WindowLinkSelection:D)","references":[{"end":61,"start":40,"target":"LibTmux::Model::WindowLinkSelection"}],"returns":"WindowLinkSelection:D","nativeSyntax":[{"start":7,"end":25,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-window-links","declaration":true},{"text":"(*%options --> "},{"text":"WindowLinkSelection:D","target":"LibTmux::Model::WindowLinkSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":438,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query-window-links"},{"apiScope":"exported","doc":{"body":"Acquire unique physical windows, preserving link context separately.","summary":"Acquire unique physical windows, preserving link context separately."},"id":"LibTmux::Server.query-windows","kind":"method","modifiers":[],"name":"query-windows","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.query-windows","signatures":[{"params":[{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method query-windows(*%options --> WindowSelection:D)","references":[{"end":52,"start":35,"target":"LibTmux::Model::WindowSelection"}],"returns":"WindowSelection:D","nativeSyntax":[{"start":7,"end":20,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"query-windows","declaration":true},{"text":"(*%options --> "},{"text":"WindowSelection:D","target":"LibTmux::Model::WindowSelection"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":436,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-query-windows"},{"apiScope":"exported","doc":{"body":"Run a declared batch with one observed incarnation and a shared deadline.","summary":"Run a declared batch with one observed incarnation and a shared deadline."},"id":"LibTmux::Server.run-batch","kind":"method","modifiers":[],"name":"run-batch","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.run-batch","signatures":[{"params":[{"keywordOnly":false,"name":"$batch","optional":false,"type":"LibTmux::Batch::Batch:D"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method run-batch(LibTmux::Batch::Batch:D $batch, *%options --> LibTmux::Batch::Report:D)","references":[{"end":40,"start":17,"target":"LibTmux::Batch::Batch"},{"end":87,"start":63,"target":"LibTmux::Batch::Report"}],"returns":"LibTmux::Batch::Report:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run-batch","declaration":true},{"text":"("},{"text":"LibTmux::Batch::Batch:D","target":"LibTmux::Batch::Batch"},{"text":" $batch, *%options --> "},{"text":"LibTmux::Batch::Report:D","target":"LibTmux::Batch::Report"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":608,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-run-batch"},{"apiScope":"exported","doc":{"body":"Resolve per-operation outcomes with one deadline spanning observation and dispatch.","summary":"Resolve per-operation outcomes with one deadline spanning observation and dispatch."},"id":"LibTmux::Server.run-batch-async","kind":"method","modifiers":[],"name":"run-batch-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.run-batch-async","signatures":[{"params":[{"keywordOnly":false,"name":"$batch","optional":false,"type":"LibTmux::Batch::Batch:D"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"},{"default":"'stop'","keywordOnly":true,"name":"$on-error","optional":true,"type":"Str:D"}],"raw":"method run-batch-async(LibTmux::Batch::Batch:D $batch, Cancellation :$cancel = Cancellation,\n                       Str:D :$on-error = 'stop' --> Promise:D)","references":[{"end":46,"start":23,"target":"LibTmux::Batch::Batch"},{"end":67,"start":55,"target":"LibTmux::Transport::Cancellation"},{"end":91,"start":79,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run-batch-async","declaration":true},{"text":"("},{"text":"LibTmux::Batch::Batch:D","target":"LibTmux::Batch::Batch"},{"text":" $batch, "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":",\n                       Str:D :$on-error = 'stop' --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":612,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-run-batch-async"},{"apiScope":"exported","doc":{"body":"Run literal shell source through tmux. Background acknowledgement is not job completion.","summary":"Run literal shell source through tmux. Background acknowledgement is not job completion."},"id":"LibTmux::Server.run-shell","kind":"method","modifiers":[],"name":"run-shell","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.run-shell","signatures":[{"params":[{"keywordOnly":false,"name":"$script","optional":false,"type":"Mu"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method run-shell(Mu $script, *%options --> Result:D)","references":[{"end":51,"start":43,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run-shell","declaration":true},{"text":"(Mu $script, *%options --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":483,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-run-shell"},{"apiScope":"exported","doc":{"body":"Resolve the bounded tmux job request; cancellation does not undo a server-side job.","summary":"Resolve the bounded tmux job request; cancellation does not undo a server-side job."},"id":"LibTmux::Server.run-shell-async","kind":"method","modifiers":[],"name":"run-shell-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.run-shell-async","signatures":[{"params":[{"keywordOnly":false,"name":"$script","optional":false,"type":"Mu"},{"default":"False","keywordOnly":true,"name":"$background","optional":true,"type":"Mu"},{"default":"PaneId","keywordOnly":true,"name":"$pane","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method run-shell-async(Mu $script, Mu :$background = False, Mu :$pane = PaneId,\n                       Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":78,"start":72,"target":"LibTmux::Types::PaneId"},{"end":115,"start":103,"target":"LibTmux::Transport::Cancellation"},{"end":139,"start":127,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":22,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"run-shell-async","declaration":true},{"text":"(Mu $script, Mu :$background = False, Mu :$pane = "},{"text":"PaneId","target":"LibTmux::Types::PaneId"},{"text":",\n                       "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":485,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-run-shell-async"},{"apiScope":"exported","doc":{"body":"Acquire a captured graph explicitly. Existing snapshots remain unchanged.","summary":"Acquire a captured graph explicitly. Existing snapshots remain unchanged."},"id":"LibTmux::Server.snapshot","kind":"method","modifiers":[],"name":"snapshot","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.snapshot","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method snapshot(Cancellation :$cancel = Cancellation --> Snapshot:D)","references":[{"end":28,"start":16,"target":"LibTmux::Transport::Cancellation"},{"end":52,"start":40,"target":"LibTmux::Transport::Cancellation"},{"end":67,"start":57,"target":"LibTmux::Model::Snapshot"}],"returns":"Snapshot:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"Snapshot:D","target":"LibTmux::Model::Snapshot"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":375,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-snapshot"},{"apiScope":"exported","doc":{"body":"Resolve a fresh captured graph; cancellation propagates through every acquisition stage.","summary":"Resolve a fresh captured graph; cancellation propagates through every acquisition stage."},"id":"LibTmux::Server.snapshot-async","kind":"method","modifiers":[],"name":"snapshot-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.snapshot-async","signatures":[{"params":[{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method snapshot-async(Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":34,"start":22,"target":"LibTmux::Transport::Cancellation"},{"end":58,"start":46,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"snapshot-async","declaration":true},{"text":"("},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":377,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-snapshot-async"},{"apiScope":"exported","doc":{"body":"Source one literal local pathname; parse-only validates without running its commands.","summary":"Source one literal local pathname; parse-only validates without running its commands."},"id":"LibTmux::Server.source-file","kind":"method","modifiers":[],"name":"source-file","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.source-file","signatures":[{"params":[{"keywordOnly":false,"name":"$path","optional":false,"type":"Mu"},{"default":"False","keywordOnly":true,"name":"$parse-only","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method source-file(Mu $path, Mu :$parse-only = False,\n                   Cancellation :$cancel = Cancellation --> Result:D)","references":[{"end":85,"start":73,"target":"LibTmux::Transport::Cancellation"},{"end":109,"start":97,"target":"LibTmux::Transport::Cancellation"},{"end":122,"start":114,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":18,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"source-file","declaration":true},{"text":"(Mu $path, Mu :$parse-only = False,\n                   "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":512,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-source-file"},{"apiScope":"exported","doc":{"body":"Start an owned foreground daemon on a fresh private socket and create its first session.","summary":"Start an owned foreground daemon on a fresh private socket and create its first session."},"id":"LibTmux::Server.start","kind":"method","modifiers":[],"name":"start","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.start","signatures":[{"params":[{"default":"'main'","keywordOnly":true,"name":"$name","optional":true},{"default":"'tmux'","keywordOnly":true,"name":"$binary","optional":true},{"default":"Str","keywordOnly":true,"name":"$shell-command","optional":true},{"default":"80","keywordOnly":true,"name":"$width","optional":true},{"default":"24","keywordOnly":true,"name":"$height","optional":true},{"default":"%*ENV","keywordOnly":true,"name":"$environment","optional":true},{"default":"$*CWD","keywordOnly":true,"name":"$cwd","optional":true},{"default":"10_000","keywordOnly":true,"name":"$timeout-ms","optional":true},{"default":"8 * 1024 * 1024","keywordOnly":true,"name":"$max-output-bytes","optional":true},{"default":"12 * 1024","keywordOnly":true,"name":"$max-command-bytes","optional":true},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true}],"raw":"method start(:$name = 'main', :$binary = 'tmux', :$shell-command = Str,\n             :$width = 80, :$height = 24, :$environment = %*ENV, :$cwd = $*CWD,\n             :$timeout-ms = 10_000, :$max-output-bytes = 8 * 1024 * 1024,\n             :$max-command-bytes = 12 * 1024, :$cancel = Cancellation)","references":[{"end":295,"start":283,"target":"LibTmux::Transport::Cancellation"}],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"start","declaration":true},{"text":"(:$name = 'main', :$binary = 'tmux', :$shell-command = Str,\n             :$width = 80, :$height = 24, :$environment = %*ENV, :$cwd = $*CWD,\n             :$timeout-ms = 10_000, :$max-output-bytes = 8 * 1024 * 1024,\n             :$max-command-bytes = 12 * 1024, :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":622,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-start"},{"apiScope":"exported","doc":{"body":"Wait, signal, lock or unlock a named channel; timeout cannot undo server-side effects.","summary":"Wait, signal, lock or unlock a named channel; timeout cannot undo server-side effects."},"id":"LibTmux::Server.wait-for","kind":"method","modifiers":[],"name":"wait-for","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.wait-for","signatures":[{"params":[{"keywordOnly":false,"name":"$channel","optional":false,"type":"Mu"},{"keywordOnly":false,"name":"%options","optional":false}],"raw":"method wait-for(Mu $channel, *%options --> Result:D)","references":[{"end":51,"start":43,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":15,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"wait-for","declaration":true},{"text":"(Mu $channel, *%options --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":524,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-wait-for"},{"apiScope":"exported","doc":{"body":"Resolve one channel operation within the Server deadline, without readiness polling.","summary":"Resolve one channel operation within the Server deadline, without readiness polling."},"id":"LibTmux::Server.wait-for-async","kind":"method","modifiers":[],"name":"wait-for-async","package":"LibTmux","parent":"LibTmux::Server","product":"core","publicId":"LibTmux::Server.wait-for-async","signatures":[{"params":[{"keywordOnly":false,"name":"$channel","optional":false,"type":"Mu"},{"default":"'wait'","keywordOnly":true,"name":"$action","optional":true,"type":"Mu"},{"default":"Cancellation","keywordOnly":true,"name":"$cancel","optional":true,"type":"Cancellation"}],"raw":"method wait-for-async(Mu $channel, Mu :$action = 'wait',\n                     Cancellation :$cancel = Cancellation --> Promise:D)","references":[{"end":90,"start":78,"target":"LibTmux::Transport::Cancellation"},{"end":114,"start":102,"target":"LibTmux::Transport::Cancellation"}],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"wait-for-async","declaration":true},{"text":"(Mu $channel, Mu :$action = 'wait',\n                     "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" :$cancel = "},{"text":"Cancellation","target":"LibTmux::Transport::Cancellation"},{"text":" --> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Server.rakumod","line":526,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-server-wait-for-async"},{"apiScope":"exported","doc":{"body":"# Bounded child processes\n\nExecutor accepts a nonempty positional argv of defined, NUL-free strings.\nIt invokes that executable directly. Shell syntax, tmux command syntax and\nFORMAT expansion belong to callers above this layer.\n\n` execute ` returns a Result. ` execute-async ` always returns a Promise,\nincluding for invalid arguments or closed admission. Each call copies argv,\nenvironment entries and input bytes before asynchronous work begins. An\nomitted environment copies the current environment; an explicit empty mapping\npasses no variables. Input is a Blob, and the child receives EOF after those\nbytes are written. Both output streams are binary and drain concurrently.\n\n` timeout-ms ` bounds an admitted operation, ` max-output-bytes ` bounds combined\nretained stdout/stderr, and ` cleanup-timeout-ms ` bounds waiting after forced\ntermination. Their defaults are 10000 ms, 8388608 bytes and 1000 ms. All are\npositive integers. Encoded tmux command size has a separate Engine policy.\n` execute ` and ` execute-async ` accept an optional ` timeout-ms ` override for\ncallers sharing one deadline across several child operations.\n\nBy default a nonzero exit or signal throws X::LibTmux::Command. ` :!check `\nreturns its Result with outcome Failed instead. Spawn failure, invalid input,\ntimeout, cancellation, output overflow and I/O failures still throw. Error\nrecords retain bounded output bytes, process identity and reaping evidence.\nNotStarted means no child effects were admitted. Failed and Indeterminate do\nnot mean that earlier effects were rolled back. Complete means child process\ncompletion, not completion of a program controlled through tmux.\n\nCancellation is one shot. Dropping an operation Promise does not cancel its\nchild. Explicit cancellation and executor close terminate admitted children;\nclose callers share one Promise. A close failure remains observable on later\nclose calls. The executor owns direct child clients, not programs deliberately\nstarted in a tmux pane or arbitrary descendant daemons.\nExecutor and Cancellation cannot be cloned. Result clones reconstruct and\nvalidate replacement attributes, copying output bytes again.","summary":""},"id":"LibTmux::Transport","kind":"module","modifiers":[],"name":"Transport","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Transport","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":2,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport"},{"apiScope":"exported","doc":{"body":"One-shot cancellation shared by explicitly selected operations.","summary":"One-shot cancellation shared by explicitly selected operations."},"id":"LibTmux::Transport::Cancellation","kind":"class","modifiers":[],"name":"Cancellation","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::Cancellation","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":11,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-cancellation"},{"apiScope":"exported","doc":{"body":"Cancel all subscribed operations once; repeated calls have no further effect.","summary":"Cancel all subscribed operations once; repeated calls have no further effect."},"id":"LibTmux::Transport::Cancellation.cancel","kind":"method","modifiers":[],"name":"cancel","package":"LibTmux","parent":"LibTmux::Transport::Cancellation","product":"core","publicId":"LibTmux::Transport::Cancellation.cancel","signatures":[{"params":[],"raw":"method cancel(--> Nil)","references":[],"returns":"Nil","nativeSyntax":[{"start":7,"end":13,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"cancel","declaration":true},{"text":"(--> Nil)"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":29,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-cancellation-cancel"},{"apiScope":"exported","doc":{"body":"Read cancellation state without I/O.","summary":"Read cancellation state without I/O."},"id":"LibTmux::Transport::Cancellation.cancelled","kind":"method","modifiers":[],"name":"cancelled","package":"LibTmux","parent":"LibTmux::Transport::Cancellation","product":"core","publicId":"LibTmux::Transport::Cancellation.cancelled","signatures":[{"params":[],"raw":"method cancelled(--> Bool:D)","references":[],"returns":"Bool:D","nativeSyntax":[{"start":7,"end":16,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"cancelled","declaration":true},{"text":"(--> Bool:D)"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-cancellation-cancelled"},{"apiScope":"exported","doc":{"body":"Lifecycle owners cannot share mutable state through a shallow clone.","summary":"Lifecycle owners cannot share mutable state through a shallow clone."},"id":"LibTmux::Transport::Cancellation.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Transport::Cancellation","product":"core","publicId":"LibTmux::Transport::Cancellation.clone","signatures":[{"params":[{"keywordOnly":false,"name":"|","optional":false}],"raw":"method clone(|)","references":[],"nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(|)"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":23,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-cancellation-clone"},{"apiScope":"exported","doc":{"body":"Observe cancellation through a Promise which only this token can resolve.","summary":"Observe cancellation through a Promise which only this token can resolve."},"id":"LibTmux::Transport::Cancellation.when-cancelled","kind":"method","modifiers":[],"name":"when-cancelled","package":"LibTmux","parent":"LibTmux::Transport::Cancellation","product":"core","publicId":"LibTmux::Transport::Cancellation.when-cancelled","signatures":[{"params":[],"raw":"method when-cancelled(--> Promise:D)","references":[],"returns":"Promise:D","nativeSyntax":[{"start":7,"end":21,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"when-cancelled","declaration":true},{"text":"(--> Promise:D)"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-cancellation-when-cancelled"},{"apiScope":"exported","doc":{"body":"Captured child output. Complete means process completion, not application effects.","summary":"Captured child output. Complete means process completion, not application effects."},"id":"LibTmux::Transport::Result","kind":"class","modifiers":[],"name":"Result","package":"LibTmux","parent":"LibTmux::Transport","product":"core","publicId":"LibTmux::Transport::Result","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":62,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-result"},{"apiScope":"exported","doc":{"body":"Reconstruct copies through the constructor, including replacement byte buffers.","summary":"Reconstruct copies through the constructor, including replacement byte buffers."},"id":"LibTmux::Transport::Result.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> Result:D)","references":[{"end":35,"start":27,"target":"LibTmux::Transport::Result"}],"returns":"Result:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"Result:D","target":"LibTmux::Transport::Result"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":87,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-result-clone"},{"apiScope":"exported","doc":{"body":"Child exit status; inspect signal separately for signal termination.","summary":"Child exit status; inspect signal separately for signal termination."},"id":"LibTmux::Transport::Result.exitcode","kind":"property","modifiers":[],"name":"exitcode","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.exitcode","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-transport-result-exitcode"},{"apiScope":"exported","doc":{"body":"Known command outcome; Complete does not prove an external application effect.","summary":"Known command outcome; Complete does not prove an external application effect."},"id":"LibTmux::Transport::Result.outcome","kind":"property","modifiers":[],"name":"outcome","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.outcome","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":76,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Outcome:D","slug":"libtmux-transport-result-outcome"},{"apiScope":"exported","doc":{"body":"Retained stdout and stderr bytes, excluding fixed metadata and object overhead.","summary":"Retained stdout and stderr bytes, excluding fixed metadata and object overhead."},"id":"LibTmux::Transport::Result.output-bytes","kind":"method","modifiers":[],"name":"output-bytes","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.output-bytes","signatures":[{"params":[],"raw":"method output-bytes(--> Count:D)","references":[{"end":31,"start":24,"target":"LibTmux::Types::Count"}],"returns":"Count:D","nativeSyntax":[{"start":7,"end":19,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"output-bytes","declaration":true},{"text":"(--> "},{"text":"Count:D","target":"LibTmux::Types::Count"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Transport.rakumod","line":84,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-transport-result-output-bytes"},{"apiScope":"exported","doc":{"body":"Owned client process ID associated with this result.","summary":"Owned client process ID associated with this result."},"id":"LibTmux::Transport::Result.pid","kind":"property","modifiers":[],"name":"pid","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.pid","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":72,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-transport-result-pid"},{"apiScope":"exported","doc":{"body":"Whether the owned client completion was joined.","summary":"Whether the owned client completion was joined."},"id":"LibTmux::Transport::Result.reaped","kind":"property","modifiers":[],"name":"reaped","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.reaped","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"libtmux-transport-result-reaped"},{"apiScope":"exported","doc":{"body":"Terminating signal number, or zero for ordinary process exit.","summary":"Terminating signal number, or zero for ordinary process exit."},"id":"LibTmux::Transport::Result.signal","kind":"property","modifiers":[],"name":"signal","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.signal","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":70,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int:D","slug":"libtmux-transport-result-signal"},{"apiScope":"exported","doc":{"body":"Captured stderr bytes, drained concurrently with stdout.","summary":"Captured stderr bytes, drained concurrently with stdout."},"id":"LibTmux::Transport::Result.stderr","kind":"property","modifiers":[],"name":"stderr","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.stderr","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":66,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-transport-result-stderr"},{"apiScope":"exported","doc":{"body":"Captured stdout bytes; no text normalization or implicit decoding is applied.","summary":"Captured stdout bytes; no text normalization or implicit decoding is applied."},"id":"LibTmux::Transport::Result.stdout","kind":"property","modifiers":[],"name":"stdout","package":"LibTmux","parent":"LibTmux::Transport::Result","product":"core","publicId":"LibTmux::Transport::Result.stdout","signatures":[],"source":{"file":"lib/LibTmux/Transport.rakumod","line":64,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"libtmux-transport-result-stdout"},{"apiScope":"exported","doc":{"body":"# Identifiers and states\n\nIDs validate ASCII spelling only. Store daemon identity separately and check\nit before operations. WindowLink identity additionally includes session/index;\nan observed index is not a permanent link identifier.\n\nValueState describes field availability. KnownNull is domain absence;\nUnloaded means acquisition omitted data, and Unavailable means the selected\nacquisition context cannot supply it. Unsupported is a capability refusal.\nNone of these states is encoded as an empty string or numeric zero.","summary":""},"id":"LibTmux::Types","kind":"module","modifiers":[],"name":"Types","package":"LibTmux","parent":"LibTmux","product":"core","publicId":"LibTmux::Types","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":3,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types"},{"apiScope":"exported","doc":{"body":"A nonnegative count or dimension. Bool is deliberately not a number here.","summary":"A nonnegative count or dimension. Bool is deliberately not a number here."},"id":"LibTmux::Types::Count","kind":"typealias","modifiers":[],"name":"Count","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::Count","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":12,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-count"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome","kind":"enum","modifiers":[],"name":"Outcome","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::Outcome","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-outcome"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome.Complete","kind":"constant","modifiers":[],"name":"Complete","package":"LibTmux","parent":"LibTmux::Types::Outcome","product":"core","publicId":"LibTmux::Types::Outcome.Complete","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"1","slug":"libtmux-types-outcome-complete"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome.Failed","kind":"constant","modifiers":[],"name":"Failed","package":"LibTmux","parent":"LibTmux::Types::Outcome","product":"core","publicId":"LibTmux::Types::Outcome.Failed","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"2","slug":"libtmux-types-outcome-failed"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome.Indeterminate","kind":"constant","modifiers":[],"name":"Indeterminate","package":"LibTmux","parent":"LibTmux::Types::Outcome","product":"core","publicId":"LibTmux::Types::Outcome.Indeterminate","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"4","slug":"libtmux-types-outcome-indeterminate"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome.NotStarted","kind":"constant","modifiers":[],"name":"NotStarted","package":"LibTmux","parent":"LibTmux::Types::Outcome","product":"core","publicId":"LibTmux::Types::Outcome.NotStarted","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"0","slug":"libtmux-types-outcome-notstarted"},{"apiScope":"exported","doc":{"body":"What the caller knows about an operation's effects.","summary":"What the caller knows about an operation's effects."},"id":"LibTmux::Types::Outcome.Skipped","kind":"constant","modifiers":[],"name":"Skipped","package":"LibTmux","parent":"LibTmux::Types::Outcome","product":"core","publicId":"LibTmux::Types::Outcome.Skipped","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"3","slug":"libtmux-types-outcome-skipped"},{"apiScope":"exported","doc":{"body":"A pane identifier scoped to a captured daemon incarnation.","summary":"A pane identifier scoped to a captured daemon incarnation."},"id":"LibTmux::Types::PaneId","kind":"typealias","modifiers":[],"name":"PaneId","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::PaneId","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":10,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-paneid"},{"apiScope":"exported","doc":{"body":"A positive dimension or resource limit.","summary":"A positive dimension or resource limit."},"id":"LibTmux::Types::Positive","kind":"typealias","modifiers":[],"name":"Positive","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::Positive","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":14,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-positive"},{"apiScope":"exported","doc":{"body":"A session identifier's spelling; existence and daemon ownership are separate.","summary":"A session identifier's spelling; existence and daemon ownership are separate."},"id":"LibTmux::Types::SessionId","kind":"typealias","modifiers":[],"name":"SessionId","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::SessionId","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":6,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-sessionid"},{"apiScope":"exported","doc":{"body":"Capability evidence never treats an unprobed feature as supported.","summary":"Capability evidence never treats an unprobed feature as supported."},"id":"LibTmux::Types::SupportState","kind":"enum","modifiers":[],"name":"SupportState","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::SupportState","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-supportstate"},{"apiScope":"exported","doc":{"body":"Capability evidence never treats an unprobed feature as supported.","summary":"Capability evidence never treats an unprobed feature as supported."},"id":"LibTmux::Types::SupportState.NotSupported","kind":"constant","modifiers":[],"name":"NotSupported","package":"LibTmux","parent":"LibTmux::Types::SupportState","product":"core","publicId":"LibTmux::Types::SupportState.NotSupported","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"1","slug":"libtmux-types-supportstate-notsupported"},{"apiScope":"exported","doc":{"body":"Capability evidence never treats an unprobed feature as supported.","summary":"Capability evidence never treats an unprobed feature as supported."},"id":"LibTmux::Types::SupportState.Supported","kind":"constant","modifiers":[],"name":"Supported","package":"LibTmux","parent":"LibTmux::Types::SupportState","product":"core","publicId":"LibTmux::Types::SupportState.Supported","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"0","slug":"libtmux-types-supportstate-supported"},{"apiScope":"exported","doc":{"body":"Capability evidence never treats an unprobed feature as supported.","summary":"Capability evidence never treats an unprobed feature as supported."},"id":"LibTmux::Types::SupportState.Unknown","kind":"constant","modifiers":[],"name":"Unknown","package":"LibTmux","parent":"LibTmux::Types::SupportState","product":"core","publicId":"LibTmux::Types::SupportState.Unknown","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"2","slug":"libtmux-types-supportstate-unknown"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState","kind":"enum","modifiers":[],"name":"ValueState","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::ValueState","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-valuestate"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState.KnownNull","kind":"constant","modifiers":[],"name":"KnownNull","package":"LibTmux","parent":"LibTmux::Types::ValueState","product":"core","publicId":"LibTmux::Types::ValueState.KnownNull","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"1","slug":"libtmux-types-valuestate-knownnull"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState.Present","kind":"constant","modifiers":[],"name":"Present","package":"LibTmux","parent":"LibTmux::Types::ValueState","product":"core","publicId":"LibTmux::Types::ValueState.Present","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"0","slug":"libtmux-types-valuestate-present"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState.Unavailable","kind":"constant","modifiers":[],"name":"Unavailable","package":"LibTmux","parent":"LibTmux::Types::ValueState","product":"core","publicId":"LibTmux::Types::ValueState.Unavailable","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"3","slug":"libtmux-types-valuestate-unavailable"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState.Unloaded","kind":"constant","modifiers":[],"name":"Unloaded","package":"LibTmux","parent":"LibTmux::Types::ValueState","product":"core","publicId":"LibTmux::Types::ValueState.Unloaded","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"4","slug":"libtmux-types-valuestate-unloaded"},{"apiScope":"exported","doc":{"body":"Availability states preserve absence without conflating false, zero or empty text.","summary":"Availability states preserve absence without conflating false, zero or empty text."},"id":"LibTmux::Types::ValueState.Unsupported","kind":"constant","modifiers":[],"name":"Unsupported","package":"LibTmux","parent":"LibTmux::Types::ValueState","product":"core","publicId":"LibTmux::Types::ValueState.Unsupported","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"value":"2","slug":"libtmux-types-valuestate-unsupported"},{"apiScope":"exported","doc":{"body":"A physical window identifier. An index in a session is a different value.","summary":"A physical window identifier. An index in a session is a different value."},"id":"LibTmux::Types::WindowId","kind":"typealias","modifiers":[],"name":"WindowId","package":"LibTmux","parent":"LibTmux::Types","product":"core","publicId":"LibTmux::Types::WindowId","signatures":[],"source":{"file":"lib/LibTmux/Types.rakumod","line":8,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"libtmux-types-windowid"},{"apiScope":"exported","doc":{"body":"Base for explicit library failures; operational failures are never absence.","summary":"Base for explicit library failures; operational failures are never absence."},"extends":["Exception"],"id":"X::LibTmux","kind":"exception","modifiers":[],"name":"LibTmux","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":9,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux"},{"apiScope":"exported","doc":{"body":"Human-readable diagnostic; typed fields carry machine-readable context.","summary":"Human-readable diagnostic; typed fields carry machine-readable context."},"id":"X::LibTmux.message","kind":"property","modifiers":[],"name":"message","package":"LibTmux","parent":"X::LibTmux","product":"core","publicId":"X::LibTmux.message","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":11,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-message"},{"apiScope":"exported","doc":{"body":"Exact or optional cardinality was violated.","summary":"Exact or optional cardinality was violated."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::Cardinality","kind":"exception","modifiers":[],"name":"Cardinality","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::Cardinality","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":82,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-cardinality"},{"apiScope":"exported","doc":{"body":"Exact number of captured matches which violated cardinality.","summary":"Exact number of captured matches which violated cardinality."},"id":"X::LibTmux::Cardinality.count","kind":"property","modifiers":[],"name":"count","package":"LibTmux","parent":"X::LibTmux::Cardinality","product":"core","publicId":"X::LibTmux::Cardinality.count","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":84,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"x-libtmux-cardinality-count"},{"apiScope":"exported","doc":{"body":"Entity schema associated with this failure.","summary":"Entity schema associated with this failure."},"id":"X::LibTmux::Cardinality.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"X::LibTmux::Cardinality","product":"core","publicId":"X::LibTmux::Cardinality.entity","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":86,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-cardinality-entity"},{"apiScope":"exported","doc":{"body":"A child command failed; outcome states whether an effect may have occurred.","summary":"A child command failed; outcome states whether an effect may have occurred."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::Command","kind":"exception","modifiers":[],"name":"Command","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::Command","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":15,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-command"},{"apiScope":"exported","doc":{"body":"Underlying failure retained when a later boundary adds context.","summary":"Underlying failure retained when a later boundary adds context."},"id":"X::LibTmux::Command.cause","kind":"property","modifiers":[],"name":"cause","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.cause","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":33,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Exception","slug":"x-libtmux-command-cause"},{"apiScope":"exported","doc":{"body":"Copy error context with validated fields and independent immutable byte buffers.","summary":"Copy error context with validated fields and independent immutable byte buffers."},"id":"X::LibTmux::Command.clone","kind":"method","modifiers":[],"name":"clone","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.clone","signatures":[{"params":[{"keywordOnly":false,"name":"%changes","optional":false}],"raw":"method clone(*%changes --> X::LibTmux::Command:D)","references":[{"end":48,"start":27,"target":"X::LibTmux::Command"}],"returns":"X::LibTmux::Command:D","nativeSyntax":[{"start":7,"end":12,"kind":"name"}],"nativeSpans":[{"text":"method "},{"text":"clone","declaration":true},{"text":"(*%changes --> "},{"text":"X::LibTmux::Command:D","target":"X::LibTmux::Command"},{"text":")"}]}],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":41,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-command-clone"},{"apiScope":"exported","doc":{"body":"Observed child exit status, when a child completion is available.","summary":"Observed child exit status, when a child completion is available."},"id":"X::LibTmux::Command.exitcode","kind":"property","modifiers":[],"name":"exitcode","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.exitcode","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":17,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"x-libtmux-command-exitcode"},{"apiScope":"exported","doc":{"body":"Failure category such as argument, spawn, exit, timeout, cancelled or cleanup.","summary":"Failure category such as argument, spawn, exit, timeout, cancelled or cleanup."},"id":"X::LibTmux::Command.kind","kind":"property","modifiers":[],"name":"kind","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.kind","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":19,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-command-kind"},{"apiScope":"exported","doc":{"body":"What is known about effects at the failure boundary.","summary":"What is known about effects at the failure boundary."},"id":"X::LibTmux::Command.outcome","kind":"property","modifiers":[],"name":"outcome","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.outcome","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":21,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Outcome:D","slug":"x-libtmux-command-outcome"},{"apiScope":"exported","doc":{"body":"Owned client process ID, when process creation was established.","summary":"Owned client process ID, when process creation was established."},"id":"X::LibTmux::Command.pid","kind":"property","modifiers":[],"name":"pid","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.pid","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":27,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"x-libtmux-command-pid"},{"apiScope":"exported","doc":{"body":"Whether cleanup established that the owned client was joined.","summary":"Whether cleanup established that the owned client was joined."},"id":"X::LibTmux::Command.reaped","kind":"property","modifiers":[],"name":"reaped","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.reaped","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":31,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Bool:D","slug":"x-libtmux-command-reaped"},{"apiScope":"exported","doc":{"body":"Observed terminating signal, when child completion is available.","summary":"Observed terminating signal, when child completion is available."},"id":"X::LibTmux::Command.signal","kind":"property","modifiers":[],"name":"signal","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.signal","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":29,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Int","slug":"x-libtmux-command-signal"},{"apiScope":"exported","doc":{"body":"Captured stderr bytes available when the operation failed.","summary":"Captured stderr bytes available when the operation failed."},"id":"X::LibTmux::Command.stderr","kind":"property","modifiers":[],"name":"stderr","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.stderr","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":25,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"x-libtmux-command-stderr"},{"apiScope":"exported","doc":{"body":"Captured stdout bytes available when the operation failed.","summary":"Captured stdout bytes available when the operation failed."},"id":"X::LibTmux::Command.stdout","kind":"property","modifiers":[],"name":"stdout","package":"LibTmux","parent":"X::LibTmux::Command","product":"core","publicId":"X::LibTmux::Command.stdout","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":23,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Blob:D","slug":"x-libtmux-command-stdout"},{"apiScope":"exported","doc":{"body":"Captured bytes violate the declared projection or field codec.","summary":"Captured bytes violate the declared projection or field codec."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::Decode","kind":"exception","modifiers":[],"name":"Decode","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::Decode","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":56,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-decode"},{"apiScope":"exported","doc":{"body":"Field or relation associated with this failure, when known.","summary":"Field or relation associated with this failure, when known."},"id":"X::LibTmux::Decode.field","kind":"property","modifiers":[],"name":"field","package":"LibTmux","parent":"X::LibTmux::Decode","product":"core","publicId":"X::LibTmux::Decode.field","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":60,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-decode-field"},{"apiScope":"exported","doc":{"body":"Zero-based byte offset in the decoder context reported by this error.","summary":"Zero-based byte offset in the decoder context reported by this error."},"id":"X::LibTmux::Decode.offset","kind":"property","modifiers":[],"name":"offset","package":"LibTmux","parent":"X::LibTmux::Decode","product":"core","publicId":"X::LibTmux::Decode.offset","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":64,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"x-libtmux-decode-offset"},{"apiScope":"exported","doc":{"body":"One-based record number; zero means no record was identified.","summary":"One-based record number; zero means no record was identified."},"id":"X::LibTmux::Decode.row","kind":"property","modifiers":[],"name":"row","package":"LibTmux","parent":"X::LibTmux::Decode","product":"core","publicId":"X::LibTmux::Decode.row","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":62,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Count:D","slug":"x-libtmux-decode-row"},{"apiScope":"exported","doc":{"body":"Declared wire or acquisition schema that rejected the input.","summary":"Declared wire or acquisition schema that rejected the input."},"id":"X::LibTmux::Decode.schema","kind":"property","modifiers":[],"name":"schema","package":"LibTmux","parent":"X::LibTmux::Decode","product":"core","publicId":"X::LibTmux::Decode.schema","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":58,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-decode-schema"},{"apiScope":"exported","doc":{"body":"Contextual rows disagree about one physical entity in a capture interval.","summary":"Contextual rows disagree about one physical entity in a capture interval."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::InconsistentSnapshot","kind":"exception","modifiers":[],"name":"InconsistentSnapshot","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::InconsistentSnapshot","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":103,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-inconsistentsnapshot"},{"apiScope":"exported","doc":{"body":"Entity schema associated with this failure.","summary":"Entity schema associated with this failure."},"id":"X::LibTmux::InconsistentSnapshot.entity","kind":"property","modifiers":[],"name":"entity","package":"LibTmux","parent":"X::LibTmux::InconsistentSnapshot","product":"core","publicId":"X::LibTmux::InconsistentSnapshot.entity","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":105,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-inconsistentsnapshot-entity"},{"apiScope":"exported","doc":{"body":"Field or relation associated with this failure, when known.","summary":"Field or relation associated with this failure, when known."},"id":"X::LibTmux::InconsistentSnapshot.field","kind":"property","modifiers":[],"name":"field","package":"LibTmux","parent":"X::LibTmux::InconsistentSnapshot","product":"core","publicId":"X::LibTmux::InconsistentSnapshot.field","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":107,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-inconsistentsnapshot-field"},{"apiScope":"exported","doc":{"body":"Criteria are invalid before any collection traversal occurs.","summary":"Criteria are invalid before any collection traversal occurs."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::InvalidFilter","kind":"exception","modifiers":[],"name":"InvalidFilter","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::InvalidFilter","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":68,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-invalidfilter"},{"apiScope":"exported","doc":{"body":"Criterion path identifying invalid query data.","summary":"Criterion path identifying invalid query data."},"id":"X::LibTmux::InvalidFilter.path","kind":"property","modifiers":[],"name":"path","package":"LibTmux","parent":"X::LibTmux::InvalidFilter","product":"core","publicId":"X::LibTmux::InvalidFilter.path","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":70,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-invalidfilter-path"},{"apiScope":"exported","doc":{"body":"A requested local field or relation was not acquired in this observation.","summary":"A requested local field or relation was not acquired in this observation."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::MissingData","kind":"exception","modifiers":[],"name":"MissingData","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::MissingData","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":74,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-missingdata"},{"apiScope":"exported","doc":{"body":"Field or relation associated with this failure, when known.","summary":"Field or relation associated with this failure, when known."},"id":"X::LibTmux::MissingData.field","kind":"property","modifiers":[],"name":"field","package":"LibTmux","parent":"X::LibTmux::MissingData","product":"core","publicId":"X::LibTmux::MissingData.field","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":76,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-missingdata-field"},{"apiScope":"exported","doc":{"body":"Availability or support state explaining this refusal.","summary":"Availability or support state explaining this refusal."},"id":"X::LibTmux::MissingData.state","kind":"property","modifiers":[],"name":"state","package":"LibTmux","parent":"X::LibTmux::MissingData","product":"core","publicId":"X::LibTmux::MissingData.state","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":78,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"ValueState:D","slug":"x-libtmux-missingdata-state"},{"apiScope":"exported","doc":{"body":"A target belongs to a daemon incarnation which is no longer current.","summary":"A target belongs to a daemon incarnation which is no longer current."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::StaleReference","kind":"exception","modifiers":[],"name":"StaleReference","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::StaleReference","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":100,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-stalereference"},{"apiScope":"exported","doc":{"body":"A capability is unavailable or not established for the connected daemon.","summary":"A capability is unavailable or not established for the connected daemon."},"extends":["X::LibTmux","Exception"],"id":"X::LibTmux::Unsupported","kind":"exception","modifiers":[],"name":"Unsupported","package":"LibTmux","parent":"LibTmux::Exceptions","product":"core","publicId":"X::LibTmux::Unsupported","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":90,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"slug":"x-libtmux-unsupported"},{"apiScope":"exported","doc":{"body":"Capability identifier which could not be established or used.","summary":"Capability identifier which could not be established or used."},"id":"X::LibTmux::Unsupported.feature","kind":"property","modifiers":[],"name":"feature","package":"LibTmux","parent":"X::LibTmux::Unsupported","product":"core","publicId":"X::LibTmux::Unsupported.feature","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":92,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-unsupported-feature"},{"apiScope":"exported","doc":{"body":"Evidence-based explanation of the unsupported or unknown capability.","summary":"Evidence-based explanation of the unsupported or unknown capability."},"id":"X::LibTmux::Unsupported.reason","kind":"property","modifiers":[],"name":"reason","package":"LibTmux","parent":"X::LibTmux::Unsupported","product":"core","publicId":"X::LibTmux::Unsupported.reason","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":96,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"Str:D","slug":"x-libtmux-unsupported-reason"},{"apiScope":"exported","doc":{"body":"Availability or support state explaining this refusal.","summary":"Availability or support state explaining this refusal."},"id":"X::LibTmux::Unsupported.state","kind":"property","modifiers":[],"name":"state","package":"LibTmux","parent":"X::LibTmux::Unsupported","product":"core","publicId":"X::LibTmux::Unsupported.state","signatures":[],"source":{"file":"lib/LibTmux/Exceptions.rakumod","line":94,"revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","repo":"libtmux/libtmux-raku","extractedRevision":"8293da87dc45f61ea2a68d1cc5327b4e62892732"},"type":"SupportState:D","slug":"x-libtmux-unsupported-state"}],"exportGroups":[{"members":["LibTmux::Attachment","LibTmux::Batch","LibTmux::Capabilities","LibTmux::Catalogue","LibTmux::Client","LibTmux::Command","LibTmux::Configuration","LibTmux::Control","LibTmux::Engine","LibTmux::Exceptions","LibTmux::Format","LibTmux::Layout","LibTmux::Model","LibTmux::Query","LibTmux::Selection","LibTmux::Server","LibTmux::Transport","LibTmux::Types"],"owner":"LibTmux","title":"Public declarations"},{"members":["LibTmux::Batch::Batch","LibTmux::Batch::Evidence","LibTmux::Batch::Operation","LibTmux::Batch::OperationResult","LibTmux::Batch::Report"],"owner":"LibTmux::Batch","title":"Public declarations"},{"members":["LibTmux::Catalogue.catalogue","LibTmux::Catalogue.parse-tmux-version","LibTmux::Catalogue.support-policy","LibTmux::Catalogue::CatalogueData","LibTmux::Catalogue::OptionSpec","LibTmux::Catalogue::SupportPolicy","LibTmux::Catalogue::TmuxVersion"],"owner":"LibTmux::Catalogue","title":"Public declarations"},{"members":["LibTmux::Client::ClientTarget","LibTmux::Client::CommandTemplate","LibTmux::Client::MenuItem"],"owner":"LibTmux::Client","title":"Public declarations"},{"members":["LibTmux::Command::Invocation"],"owner":"LibTmux::Command","title":"Public declarations"},{"members":["LibTmux::Configuration::BufferInfo","LibTmux::Configuration::Buffers","LibTmux::Configuration::Environment","LibTmux::Configuration::EnvironmentValue","LibTmux::Configuration::Hooks","LibTmux::Configuration::KeyBinding","LibTmux::Configuration::KeyBindings","LibTmux::Configuration::OptionValue","LibTmux::Configuration::Options"],"owner":"LibTmux::Configuration","title":"Public declarations"},{"members":["LibTmux::Control::Connection","LibTmux::Control::Decoder","LibTmux::Control::Event","LibTmux::Control::PaneOutput","LibTmux::Control::Response","LibTmux::Control::UnframedOutput","LibTmux::Control::UnknownEvent"],"owner":"LibTmux::Control","title":"Public declarations"},{"members":["LibTmux::Engine::Endpoint","LibTmux::Engine::Incarnation","LibTmux::Engine::Observation"],"owner":"LibTmux::Engine","title":"Public declarations"},{"members":["X::LibTmux","X::LibTmux::Cardinality","X::LibTmux::Command","X::LibTmux::Decode","X::LibTmux::InconsistentSnapshot","X::LibTmux::InvalidFilter","X::LibTmux::MissingData","X::LibTmux::StaleReference","X::LibTmux::Unsupported"],"owner":"LibTmux::Exceptions","title":"Public declarations"},{"members":["LibTmux::Format::DecodedRow","LibTmux::Format::FrameDecoder","LibTmux::Format::Projection"],"owner":"LibTmux::Format","title":"Public declarations"},{"members":["LibTmux::Layout.decode-layout","LibTmux::Layout::Layout","LibTmux::Layout::LayoutNode"],"owner":"LibTmux::Layout","title":"Public declarations"},{"members":["LibTmux::Model::Buffer","LibTmux::Model::BufferSelection","LibTmux::Model::Client","LibTmux::Model::ClientRef","LibTmux::Model::ClientSelection","LibTmux::Model::Pane","LibTmux::Model::PaneRef","LibTmux::Model::PaneSelection","LibTmux::Model::Session","LibTmux::Model::SessionGroup","LibTmux::Model::SessionGroupSelection","LibTmux::Model::SessionRef","LibTmux::Model::SessionSelection","LibTmux::Model::Snapshot","LibTmux::Model::View","LibTmux::Model::Window","LibTmux::Model::WindowLink","LibTmux::Model::WindowLinkRef","LibTmux::Model::WindowLinkSelection","LibTmux::Model::WindowRef","LibTmux::Model::WindowSelection"],"owner":"LibTmux::Model","title":"Public declarations"},{"members":["LibTmux::Query::Filter","LibTmux::Query::Limits","LibTmux::Query::Plan"],"owner":"LibTmux::Query","title":"Public declarations"},{"members":["LibTmux::Query::Plan::Plan"],"owner":"LibTmux::Query::Plan","title":"Public declarations"},{"members":["LibTmux::Selection::Selection"],"owner":"LibTmux::Selection","title":"Public declarations"},{"members":["LibTmux::Transport::Cancellation","LibTmux::Transport::Result"],"owner":"LibTmux::Transport","title":"Public declarations"},{"members":["LibTmux::Types::Count","LibTmux::Types::Outcome","LibTmux::Types::PaneId","LibTmux::Types::Positive","LibTmux::Types::SessionId","LibTmux::Types::SupportState","LibTmux::Types::ValueState","LibTmux::Types::WindowId"],"owner":"LibTmux::Types","title":"Public declarations"}],"nativeProvenance":{"exporter":{"name":"RakuAST and RakuDoc export","path":"tools/export-docs.raku","repository":"libtmux/libtmux-raku","revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","sha256":"90a32ac73358f1fabbc3e9f5f2af77d3ed2e02b0031d0ba44571c730190c0099","version":1,"workingTree":false,"compiler":"2026.09"},"files":[{"path":"META6.json","sha256":"3fffd270e9cff786830f54fc1709a153b5fe0bc2a8f7f0bcd3a618f1a332f6c2"},{"path":".tool-versions","sha256":"d0d734d93f5a364e00437b1a3d45e70e9c0b983d32476cbdcda323b9b3cec92c"},{"path":"lib/LibTmux.rakumod","sha256":"f56ddd7df0c92d14e92e701176534f218a177e656f6f686cfa3068e4b646dc7d"},{"path":"lib/LibTmux/Attachment.rakumod","sha256":"2a7d9e50c8a9e938c72af699899b7677db6e07027f98f4c5a629fee6809cb8ae"},{"path":"lib/LibTmux/Batch.rakumod","sha256":"f5d8030c453470289867ed916d7b72143ea1aa2080193fde9c2eb1525f873a2e"},{"path":"lib/LibTmux/Capabilities.rakumod","sha256":"73f7f5c9a827412690bf5da41112aa297db015565a2fe8bd2ec1ff31f9276375"},{"path":"lib/LibTmux/Catalogue.rakumod","sha256":"78a8e45195200815a3ad237ed269519c1b04155d81d20ff81e42a2c1982ce314"},{"path":"lib/LibTmux/Client.rakumod","sha256":"96b6e1f8565109da25688ce5e10e4904948189692269928534c6e716ad038da8"},{"path":"lib/LibTmux/Command.rakumod","sha256":"12e4465132b9a74f850f6eb41344a1db0d417d8aa92a68efa44908545f3c63b9"},{"path":"lib/LibTmux/Configuration.rakumod","sha256":"f0aa309b6fe6f207e3eb316848586a9e7b0bb636d51f3ca1c61daeafecf275ea"},{"path":"lib/LibTmux/Control.rakumod","sha256":"ef92f1aa474fa3a00c1e5ab2d3c9f34ccc750702c2c11cf173ad91660ac2b97e"},{"path":"lib/LibTmux/Control/Connection.rakumod","sha256":"45bf06dd372b4d3c9c9d9049ad4bd7ef32d4b5b5d4d9a0ce321606d092984e59"},{"path":"lib/LibTmux/Engine.rakumod","sha256":"a500a651c362f9eb712c86f3eda8a5a04060b3466a7f0fb6779f53e0ac329edf"},{"path":"lib/LibTmux/Exceptions.rakumod","sha256":"d98b3a0d79b2747c8582975ebee9f68899829e4775eb5f8bdc976afcd904ef4e"},{"path":"lib/LibTmux/Fields.rakumod","sha256":"d1a47e77fea2afc0fa13195988e75830c6bb664e58ee6b0c4d5653471a264cc8"},{"path":"lib/LibTmux/Format.rakumod","sha256":"f9a8245a50386b8f6f078fa32e4831d50efc74fecf8a203fc267a4bef8b47dd0"},{"path":"lib/LibTmux/Layout.rakumod","sha256":"0587c404b3f6833d609eea0d1762a83f9b1742824d6a1308144b22e41bd656d4"},{"path":"lib/LibTmux/Model.rakumod","sha256":"b68474288457b90896fa40f2f47503889fea9b9a31f2864c26d05a6c70004bfe"},{"path":"lib/LibTmux/Operations.rakumod","sha256":"f9296ef4819f7cf580bd78c0845bc33c4b3a0dd3f07a9fcd0a6f76b1f7b1d19a"},{"path":"lib/LibTmux/Query.rakumod","sha256":"a79e6a2ef199c468f43aa6c81298612fb22aa9462b7e7a283aa6fd41bdecdbd3"},{"path":"lib/LibTmux/Query/Execution.rakumod","sha256":"9412aa03bf93a588fc789802ba1f858c56268b57a6f02ecc6688d5dd95f34340"},{"path":"lib/LibTmux/Query/Plan.rakumod","sha256":"6a25c168d9110235d906fbabf3c23f2e62eaa42dfdef5c39495a88e9720f4ae6"},{"path":"lib/LibTmux/Selection.rakumod","sha256":"24851388929617fd67fc3359fe91181e146660fc08e51523f4b78189bad90e40"},{"path":"lib/LibTmux/Server.rakumod","sha256":"82df5a8ec22eefc71f120ef6904d1fd73fe65f922bf0b24e57784741c99ffd3e"},{"path":"lib/LibTmux/Transport.rakumod","sha256":"6669f3aa7fd537863281dede15cf80e703295d90f6748c17a9d4d7aea41092d6"},{"path":"lib/LibTmux/Types.rakumod","sha256":"6b32babe5938d929b010fc8099100f81139de59de248d92dd415036ee1111030"},{"path":"resources/catalogue.json","sha256":"8fd2fb08308d366c98ce312ce1a7f09d601c06861e29e577294efd1b0a6515ad"},{"path":"examples/batch-recovery.raku","sha256":"2cc05efbf031c1b3ea279f41704a6655dac999cf08985eb4a26e55f79dec0f49"},{"path":"examples/floating-panes.raku","sha256":"863f9218d6541dcaad32fb9766201daf3f189a7086eb3ef13582ed9db07e7972"},{"path":"examples/query-panes.raku","sha256":"0a04cba28e76ef87babfb166ffd33958ae4d4e75f7fea2efd867a4f990b013a3"},{"path":"examples/quickstart.raku","sha256":"4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5"},{"path":"examples/session-workflow.raku","sha256":"cc93e9780e684cba5b03e112acf75f4a20ef48927e0d294d5fca2e70fb16026a"},{"path":"examples/watch-output.raku","sha256":"c94a3f505ca36a1d600b746e706129fa402175f5964d5a2f062ab916a10b557a"},{"path":"docs/reference/catalogue.rakudoc","sha256":"0c9bef61523cbbb0c8fb8f24658d3e4ca657363d54a105d617cdd38cee058047"}],"library":{"repository":"libtmux/libtmux-raku","revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","workingTree":false}}}
diff --git a/site/src/data/api/raku.nav.json b/site/src/data/api/raku.nav.json
new file mode 100644
index 000000000..1efb4aad6
--- /dev/null
+++ b/site/src/data/api/raku.nav.json
@@ -0,0 +1 @@
+{"port":"raku","buckets":[{"id":"server","label":"Server","collapsed":false},{"id":"session","label":"Session","collapsed":false},{"id":"window","label":"Window","collapsed":false},{"id":"pane","label":"Pane","collapsed":false},{"id":"client","label":"Client","collapsed":false},{"id":"hooks","label":"Hooks","collapsed":false},{"id":"options","label":"Options","collapsed":false,"children":[{"id":"options-functions","label":"Functions","collapsed":false},{"id":"options-constants","label":"Constants and variables","collapsed":false}]},{"id":"keys","label":"Keys and bindings","collapsed":false},{"id":"buffers","label":"Buffers","collapsed":false},{"id":"layout","label":"Layout and geometry","collapsed":false},{"id":"environment","label":"Environment","collapsed":false},{"id":"capabilities","label":"Terminal capabilities","collapsed":false},{"id":"version","label":"Versions","collapsed":false},{"id":"commands","label":"Commands","collapsed":false},{"id":"control","label":"Control mode","collapsed":false},{"id":"formats","label":"Formats","collapsed":false},{"id":"queries","label":"Queries","collapsed":false,"children":[{"id":"queries-fields","label":"Fields","collapsed":false},{"id":"queries-operators","label":"Operators","collapsed":false},{"id":"queries-expressions","label":"Expressions","collapsed":false}]},{"id":"snapshots","label":"Snapshots","collapsed":false},{"id":"workspace","label":"Workspaces","collapsed":false,"children":[{"id":"workspace-plan","label":"Plans","collapsed":false},{"id":"workspace-steps","label":"Steps","collapsed":false},{"id":"workspace-targets","label":"Targets and slots","collapsed":false},{"id":"workspace-session","label":"Session","collapsed":false},{"id":"workspace-window","label":"Window","collapsed":false},{"id":"workspace-pane","label":"Pane","collapsed":false},{"id":"workspace-functions","label":"Functions","collapsed":false},{"id":"workspace-constants","label":"Constants and variables","collapsed":false}]},{"id":"requests","label":"Requests","collapsed":true,"children":[{"id":"requests-server","label":"Server","collapsed":false},{"id":"requests-session","label":"Session","collapsed":false},{"id":"requests-window","label":"Window","collapsed":false},{"id":"requests-pane","label":"Pane","collapsed":false},{"id":"requests-client","label":"Client","collapsed":false}]},{"id":"errors","label":"Errors","collapsed":true,"children":[{"id":"errors-server","label":"Server","collapsed":false},{"id":"errors-session","label":"Session","collapsed":false},{"id":"errors-window","label":"Window","collapsed":false},{"id":"errors-pane","label":"Pane","collapsed":false}]},{"id":"constants","label":"Constants and enums","collapsed":true,"children":[{"id":"constants-server","label":"Server","collapsed":false},{"id":"constants-session","label":"Session","collapsed":false},{"id":"constants-window","label":"Window","collapsed":false},{"id":"constants-pane","label":"Pane","collapsed":false},{"id":"constants-client","label":"Client","collapsed":false}]},{"id":"runtime","label":"Runtime adapters","collapsed":false},{"id":"async","label":"Async","collapsed":false},{"id":"mcp","label":"MCP","collapsed":true,"children":[{"id":"mcp-functions","label":"Functions","collapsed":false},{"id":"mcp-constants","label":"Constants and variables","collapsed":false}]},{"id":"testing","label":"Testing utilities","collapsed":true},{"id":"internal","label":"Internal","collapsed":true,"children":[{"id":"internal-commands","label":"Commands","collapsed":false},{"id":"internal-options","label":"Options","collapsed":false}]}],"assignments":{"server":[{"id":"LibTmux::Engine::Endpoint","name":"Endpoint","slug":"libtmux-engine-endpoint","kind":"class"},{"id":"LibTmux::Engine::Incarnation","name":"Incarnation","slug":"libtmux-engine-incarnation","kind":"class"},{"id":"LibTmux::Engine::Observation","name":"Observation","slug":"libtmux-engine-observation","kind":"class"},{"id":"LibTmux::Server","name":"Server","slug":"libtmux-server","kind":"class"}],"session":[{"id":"LibTmux::Model::Session","name":"Session","slug":"libtmux-model-session","kind":"class"},{"id":"LibTmux::Model::SessionGroup","name":"SessionGroup","slug":"libtmux-model-sessiongroup","kind":"class"},{"id":"LibTmux::Model::SessionGroupSelection","name":"SessionGroupSelection","slug":"libtmux-model-sessiongroupselection","kind":"class"},{"id":"LibTmux::Model::SessionRef","name":"SessionRef","slug":"libtmux-model-sessionref","kind":"class"},{"id":"LibTmux::Model::SessionSelection","name":"SessionSelection","slug":"libtmux-model-sessionselection","kind":"class"},{"id":"LibTmux::Types::SessionId","name":"SessionId","slug":"libtmux-types-sessionid","kind":"typealias"}],"window":[{"id":"LibTmux::Model::Window","name":"Window","slug":"libtmux-model-window","kind":"class"},{"id":"LibTmux::Model::WindowLink","name":"WindowLink","slug":"libtmux-model-windowlink","kind":"class"},{"id":"LibTmux::Model::WindowLinkRef","name":"WindowLinkRef","slug":"libtmux-model-windowlinkref","kind":"class"},{"id":"LibTmux::Model::WindowLinkSelection","name":"WindowLinkSelection","slug":"libtmux-model-windowlinkselection","kind":"class"},{"id":"LibTmux::Model::WindowRef","name":"WindowRef","slug":"libtmux-model-windowref","kind":"class"},{"id":"LibTmux::Model::WindowSelection","name":"WindowSelection","slug":"libtmux-model-windowselection","kind":"class"},{"id":"LibTmux::Types::WindowId","name":"WindowId","slug":"libtmux-types-windowid","kind":"typealias"}],"pane":[{"id":"LibTmux::Model::Pane","name":"Pane","slug":"libtmux-model-pane","kind":"class"},{"id":"LibTmux::Model::PaneRef","name":"PaneRef","slug":"libtmux-model-paneref","kind":"class"},{"id":"LibTmux::Model::PaneSelection","name":"PaneSelection","slug":"libtmux-model-paneselection","kind":"class"},{"id":"LibTmux::Types::PaneId","name":"PaneId","slug":"libtmux-types-paneid","kind":"typealias"}],"client":[{"id":"LibTmux::Attachment","name":"Attachment","slug":"libtmux-attachment","kind":"class"},{"id":"LibTmux::Client","name":"Client","slug":"libtmux-client","kind":"module"},{"id":"LibTmux::Client::ClientTarget","name":"ClientTarget","slug":"libtmux-client-clienttarget","kind":"class"},{"id":"LibTmux::Client::MenuItem","name":"MenuItem","slug":"libtmux-client-menuitem","kind":"class"},{"id":"LibTmux::Model::Client","name":"Client","slug":"libtmux-model-client","kind":"class"},{"id":"LibTmux::Model::ClientRef","name":"ClientRef","slug":"libtmux-model-clientref","kind":"class"},{"id":"LibTmux::Model::ClientSelection","name":"ClientSelection","slug":"libtmux-model-clientselection","kind":"class"}],"hooks":[{"id":"LibTmux::Configuration::Hooks","name":"Hooks","slug":"libtmux-configuration-hooks","kind":"class"}],"options":[{"id":"LibTmux::Catalogue::OptionSpec","name":"OptionSpec","slug":"libtmux-catalogue-optionspec","kind":"class"},{"id":"LibTmux::Configuration::OptionValue","name":"OptionValue","slug":"libtmux-configuration-optionvalue","kind":"class"}],"options-functions":[],"options-constants":[],"keys":[{"id":"LibTmux::Configuration::KeyBinding","name":"KeyBinding","slug":"libtmux-configuration-keybinding","kind":"class"},{"id":"LibTmux::Configuration::KeyBindings","name":"KeyBindings","slug":"libtmux-configuration-keybindings","kind":"class"}],"buffers":[{"id":"LibTmux::Configuration::BufferInfo","name":"BufferInfo","slug":"libtmux-configuration-bufferinfo","kind":"class"},{"id":"LibTmux::Configuration::Buffers","name":"Buffers","slug":"libtmux-configuration-buffers","kind":"class"},{"id":"LibTmux::Model::Buffer","name":"Buffer","slug":"libtmux-model-buffer","kind":"class"},{"id":"LibTmux::Model::BufferSelection","name":"BufferSelection","slug":"libtmux-model-bufferselection","kind":"class"}],"layout":[{"id":"LibTmux::Layout","name":"Layout","slug":"libtmux-layout","kind":"module"},{"id":"LibTmux::Layout::Layout","name":"Layout","slug":"libtmux-layout-layout","kind":"class"},{"id":"LibTmux::Layout.decode-layout","name":"decode-layout","slug":"libtmux-layout-decode-layout","kind":"function"}],"environment":[{"id":"LibTmux::Configuration::Environment","name":"Environment","slug":"libtmux-configuration-environment","kind":"class"},{"id":"LibTmux::Configuration::EnvironmentValue","name":"EnvironmentValue","slug":"libtmux-configuration-environmentvalue","kind":"class"}],"capabilities":[{"id":"LibTmux::Capabilities","name":"Capabilities","slug":"libtmux-capabilities","kind":"class"}],"version":[{"id":"LibTmux::Catalogue","name":"Catalogue","slug":"libtmux-catalogue","kind":"module"},{"id":"LibTmux::Catalogue::CatalogueData","name":"CatalogueData","slug":"libtmux-catalogue-cataloguedata","kind":"class"},{"id":"LibTmux::Catalogue::SupportPolicy","name":"SupportPolicy","slug":"libtmux-catalogue-supportpolicy","kind":"class"},{"id":"LibTmux::Catalogue::TmuxVersion","name":"TmuxVersion","slug":"libtmux-catalogue-tmuxversion","kind":"class"},{"id":"LibTmux::Types::SupportState","name":"SupportState","slug":"libtmux-types-supportstate","kind":"enum"},{"id":"LibTmux::Catalogue.catalogue","name":"catalogue","slug":"libtmux-catalogue-catalogue","kind":"function"},{"id":"LibTmux::Catalogue.parse-tmux-version","name":"parse-tmux-version","slug":"libtmux-catalogue-parse-tmux-version","kind":"function"},{"id":"LibTmux::Catalogue.support-policy","name":"support-policy","slug":"libtmux-catalogue-support-policy","kind":"function"}],"commands":[{"id":"LibTmux::Batch","name":"Batch","slug":"libtmux-batch","kind":"module"},{"id":"LibTmux::Batch::Batch","name":"Batch","slug":"libtmux-batch-batch","kind":"class"},{"id":"LibTmux::Batch::Evidence","name":"Evidence","slug":"libtmux-batch-evidence","kind":"class"},{"id":"LibTmux::Batch::Operation","name":"Operation","slug":"libtmux-batch-operation","kind":"class"},{"id":"LibTmux::Batch::Report","name":"Report","slug":"libtmux-batch-report","kind":"class"},{"id":"LibTmux::Client::CommandTemplate","name":"CommandTemplate","slug":"libtmux-client-commandtemplate","kind":"class"},{"id":"LibTmux::Command","name":"Command","slug":"libtmux-command","kind":"module"},{"id":"LibTmux::Command::Invocation","name":"Invocation","slug":"libtmux-command-invocation","kind":"class"},{"id":"LibTmux::Transport","name":"Transport","slug":"libtmux-transport","kind":"module"},{"id":"LibTmux::Transport::Cancellation","name":"Cancellation","slug":"libtmux-transport-cancellation","kind":"class"},{"id":"LibTmux::Types::Outcome","name":"Outcome","slug":"libtmux-types-outcome","kind":"enum"}],"control":[{"id":"LibTmux::Control","name":"Control","slug":"libtmux-control","kind":"module"},{"id":"LibTmux::Control::Connection","name":"Connection","slug":"libtmux-control-connection","kind":"class"},{"id":"LibTmux::Control::Decoder","name":"Decoder","slug":"libtmux-control-decoder","kind":"class"},{"id":"LibTmux::Control::PaneOutput","name":"PaneOutput","slug":"libtmux-control-paneoutput","kind":"class"},{"id":"LibTmux::Control::Response","name":"Response","slug":"libtmux-control-response","kind":"class"},{"id":"LibTmux::Control::UnframedOutput","name":"UnframedOutput","slug":"libtmux-control-unframedoutput","kind":"class"}],"formats":[{"id":"LibTmux::Format","name":"Format","slug":"libtmux-format","kind":"module"},{"id":"LibTmux::Format::DecodedRow","name":"DecodedRow","slug":"libtmux-format-decodedrow","kind":"class"},{"id":"LibTmux::Format::FrameDecoder","name":"FrameDecoder","slug":"libtmux-format-framedecoder","kind":"class"},{"id":"LibTmux::Format::Projection","name":"Projection","slug":"libtmux-format-projection","kind":"class"}],"queries":[{"id":"LibTmux::Query","name":"Query","slug":"libtmux-query","kind":"module"},{"id":"LibTmux::Query::Filter","name":"Filter","slug":"libtmux-query-filter","kind":"class"},{"id":"LibTmux::Query::Limits","name":"Limits","slug":"libtmux-query-limits","kind":"class"},{"id":"LibTmux::Query::Plan","name":"Plan","slug":"libtmux-query-plan","kind":"module"},{"id":"LibTmux::Query::Plan::Plan","name":"Plan","slug":"libtmux-query-plan-plan","kind":"class"},{"id":"LibTmux::Selection","name":"Selection","slug":"libtmux-selection","kind":"module"},{"id":"LibTmux::Selection::Selection","name":"Selection","slug":"libtmux-selection-selection","kind":"trait"}],"queries-fields":[],"queries-operators":[],"queries-expressions":[{"id":"LibTmux::Layout::LayoutNode","name":"LayoutNode","slug":"libtmux-layout-layoutnode","kind":"class"}],"snapshots":[{"id":"LibTmux::Model::Snapshot","name":"Snapshot","slug":"libtmux-model-snapshot","kind":"class"},{"id":"LibTmux::Model::View","name":"View","slug":"libtmux-model-view","kind":"class"},{"id":"LibTmux::Types::ValueState","name":"ValueState","slug":"libtmux-types-valuestate","kind":"enum"}],"workspace":[],"workspace-plan":[],"workspace-steps":[],"workspace-targets":[],"workspace-session":[],"workspace-window":[],"workspace-pane":[],"workspace-functions":[],"workspace-constants":[],"requests":[],"requests-server":[],"requests-session":[],"requests-window":[],"requests-pane":[],"requests-client":[],"errors":[{"id":"LibTmux::Exceptions","name":"Exceptions","slug":"libtmux-exceptions","kind":"module"},{"id":"X::LibTmux","name":"LibTmux","slug":"x-libtmux","kind":"exception"},{"id":"X::LibTmux::Cardinality","name":"Cardinality","slug":"x-libtmux-cardinality","kind":"exception"},{"id":"X::LibTmux::Command","name":"Command","slug":"x-libtmux-command","kind":"exception"},{"id":"X::LibTmux::Decode","name":"Decode","slug":"x-libtmux-decode","kind":"exception"},{"id":"X::LibTmux::InconsistentSnapshot","name":"InconsistentSnapshot","slug":"x-libtmux-inconsistentsnapshot","kind":"exception"},{"id":"X::LibTmux::InvalidFilter","name":"InvalidFilter","slug":"x-libtmux-invalidfilter","kind":"exception"},{"id":"X::LibTmux::MissingData","name":"MissingData","slug":"x-libtmux-missingdata","kind":"exception"},{"id":"X::LibTmux::StaleReference","name":"StaleReference","slug":"x-libtmux-stalereference","kind":"exception"},{"id":"X::LibTmux::Unsupported","name":"Unsupported","slug":"x-libtmux-unsupported","kind":"exception"}],"errors-server":[],"errors-session":[],"errors-window":[],"errors-pane":[],"constants":[{"id":"LibTmux::Batch::OperationResult","name":"OperationResult","slug":"libtmux-batch-operationresult","kind":"class"},{"id":"LibTmux::Configuration::Options","name":"Options","slug":"libtmux-configuration-options","kind":"class"},{"id":"LibTmux::Control::Event","name":"Event","slug":"libtmux-control-event","kind":"class"},{"id":"LibTmux::Control::UnknownEvent","name":"UnknownEvent","slug":"libtmux-control-unknownevent","kind":"class"},{"id":"LibTmux::Transport::Result","name":"Result","slug":"libtmux-transport-result","kind":"class"}],"constants-server":[],"constants-session":[],"constants-window":[],"constants-pane":[],"constants-client":[],"runtime":[],"async":[],"mcp":[],"mcp-functions":[],"mcp-constants":[],"testing":[],"internal":[],"internal-commands":[],"internal-options":[]},"placement":{"LibTmux::Engine::Endpoint":"server","LibTmux::Engine::Incarnation":"server","LibTmux::Engine::Observation":"server","LibTmux::Server":"server","LibTmux::Model::Session":"session","LibTmux::Model::SessionGroup":"session","LibTmux::Model::SessionGroupSelection":"session","LibTmux::Model::SessionRef":"session","LibTmux::Model::SessionSelection":"session","LibTmux::Types::SessionId":"session","LibTmux::Model::Window":"window","LibTmux::Model::WindowLink":"window","LibTmux::Model::WindowLinkRef":"window","LibTmux::Model::WindowLinkSelection":"window","LibTmux::Model::WindowRef":"window","LibTmux::Model::WindowSelection":"window","LibTmux::Types::WindowId":"window","LibTmux::Model::Pane":"pane","LibTmux::Model::PaneRef":"pane","LibTmux::Model::PaneSelection":"pane","LibTmux::Types::PaneId":"pane","LibTmux::Attachment":"client","LibTmux::Client":"client","LibTmux::Client::ClientTarget":"client","LibTmux::Client::MenuItem":"client","LibTmux::Model::Client":"client","LibTmux::Model::ClientRef":"client","LibTmux::Model::ClientSelection":"client","LibTmux::Configuration::Hooks":"hooks","LibTmux::Catalogue::OptionSpec":"options","LibTmux::Configuration::OptionValue":"options","LibTmux::Configuration::KeyBinding":"keys","LibTmux::Configuration::KeyBindings":"keys","LibTmux::Configuration::BufferInfo":"buffers","LibTmux::Configuration::Buffers":"buffers","LibTmux::Model::Buffer":"buffers","LibTmux::Model::BufferSelection":"buffers","LibTmux::Layout":"layout","LibTmux::Layout.decode-layout":"layout","LibTmux::Layout::Layout":"layout","LibTmux::Configuration::Environment":"environment","LibTmux::Configuration::EnvironmentValue":"environment","LibTmux::Capabilities":"capabilities","LibTmux::Catalogue":"version","LibTmux::Catalogue.catalogue":"version","LibTmux::Catalogue.parse-tmux-version":"version","LibTmux::Catalogue.support-policy":"version","LibTmux::Catalogue::CatalogueData":"version","LibTmux::Catalogue::SupportPolicy":"version","LibTmux::Catalogue::TmuxVersion":"version","LibTmux::Types::SupportState":"version","LibTmux::Batch":"commands","LibTmux::Batch::Batch":"commands","LibTmux::Batch::Evidence":"commands","LibTmux::Batch::Operation":"commands","LibTmux::Batch::Report":"commands","LibTmux::Client::CommandTemplate":"commands","LibTmux::Command":"commands","LibTmux::Command::Invocation":"commands","LibTmux::Transport":"commands","LibTmux::Transport::Cancellation":"commands","LibTmux::Types::Outcome":"commands","LibTmux::Control":"control","LibTmux::Control::Connection":"control","LibTmux::Control::Decoder":"control","LibTmux::Control::PaneOutput":"control","LibTmux::Control::Response":"control","LibTmux::Control::UnframedOutput":"control","LibTmux::Format":"formats","LibTmux::Format::DecodedRow":"formats","LibTmux::Format::FrameDecoder":"formats","LibTmux::Format::Projection":"formats","LibTmux::Query":"queries","LibTmux::Query::Filter":"queries","LibTmux::Query::Limits":"queries","LibTmux::Query::Plan":"queries","LibTmux::Query::Plan::Plan":"queries","LibTmux::Selection":"queries","LibTmux::Selection::Selection":"queries","LibTmux::Layout::LayoutNode":"queries-expressions","LibTmux::Model::Snapshot":"snapshots","LibTmux::Model::View":"snapshots","LibTmux::Types::ValueState":"snapshots","LibTmux::Exceptions":"errors","X::LibTmux":"errors","X::LibTmux::Cardinality":"errors","X::LibTmux::Command":"errors","X::LibTmux::Decode":"errors","X::LibTmux::InconsistentSnapshot":"errors","X::LibTmux::InvalidFilter":"errors","X::LibTmux::MissingData":"errors","X::LibTmux::StaleReference":"errors","X::LibTmux::Unsupported":"errors","LibTmux::Batch::OperationResult":"constants","LibTmux::Configuration::Options":"constants","LibTmux::Control::Event":"constants","LibTmux::Control::UnknownEvent":"constants","LibTmux::Transport::Result":"constants","LibTmux":"__unplaced","LibTmux::Configuration":"__unplaced","LibTmux::Engine":"__unplaced","LibTmux::Model":"__unplaced","LibTmux::Types":"__unplaced","LibTmux::Types::Count":"__unplaced","LibTmux::Types::Positive":"__unplaced"},"unplaced":[{"id":"LibTmux","name":"LibTmux","slug":"libtmux","kind":"module"},{"id":"LibTmux::Configuration","name":"Configuration","slug":"libtmux-configuration","kind":"module"},{"id":"LibTmux::Engine","name":"Engine","slug":"libtmux-engine","kind":"module"},{"id":"LibTmux::Model","name":"Model","slug":"libtmux-model","kind":"module"},{"id":"LibTmux::Types","name":"Types","slug":"libtmux-types","kind":"module"},{"id":"LibTmux::Types::Count","name":"Count","slug":"libtmux-types-count","kind":"typealias"},{"id":"LibTmux::Types::Positive","name":"Positive","slug":"libtmux-types-positive","kind":"typealias"}],"diagnostics":{"unmatched":[],"deadBuckets":["options-functions","options-constants","queries-fields","queries-operators","workspace","workspace-plan","workspace-steps","workspace-targets","workspace-session","workspace-window","workspace-pane","workspace-functions","workspace-constants","requests","requests-server","requests-session","requests-window","requests-pane","requests-client","errors-server","errors-session","errors-window","errors-pane","constants-server","constants-session","constants-window","constants-pane","constants-client","runtime","async","mcp","mcp-functions","mcp-constants","testing","internal","internal-commands","internal-options"],"ambiguous":[],"staleUnsettled":[]}}
diff --git a/site/src/data/api/raku.paths.json b/site/src/data/api/raku.paths.json
new file mode 100644
index 000000000..43ca45dbc
--- /dev/null
+++ b/site/src/data/api/raku.paths.json
@@ -0,0 +1 @@
+{"port":"raku","repo":"libtmux/libtmux-raku","revision":"8293da87dc45f61ea2a68d1cc5327b4e62892732","paths":[".editorconfig",".github/CONTRIBUTING.md",".github/RELEASE.md",".github/WRITING.md",".github/workflows/ci.yml",".github/workflows/release.yml",".gitignore",".tool-versions","AGENTS.md","CHANGELOG.md","CLAUDE.md","LICENSE","META6.json","README.md","docs/adr/0001-tmux-compatibility.md","docs/assets/README.md","docs/assets/logo-512.png","docs/assets/logo.svg","docs/assets/opengraph-dark.png","docs/assets/opengraph-light.png","docs/documentation.rakudoc","docs/reference/catalogue.rakudoc","examples/README.md","examples/batch-recovery.raku","examples/floating-panes.raku","examples/query-panes.raku","examples/quickstart.raku","examples/session-workflow.raku","examples/watch-output.raku","lib/LibTmux.rakumod","lib/LibTmux/Attachment.rakumod","lib/LibTmux/Batch.rakumod","lib/LibTmux/Capabilities.rakumod","lib/LibTmux/Catalogue.rakumod","lib/LibTmux/Client.rakumod","lib/LibTmux/Command.rakumod","lib/LibTmux/Configuration.rakumod","lib/LibTmux/Control.rakumod","lib/LibTmux/Control/Connection.rakumod","lib/LibTmux/Engine.rakumod","lib/LibTmux/Exceptions.rakumod","lib/LibTmux/Fields.rakumod","lib/LibTmux/Format.rakumod","lib/LibTmux/Layout.rakumod","lib/LibTmux/Model.rakumod","lib/LibTmux/Operations.rakumod","lib/LibTmux/Query.rakumod","lib/LibTmux/Query/Execution.rakumod","lib/LibTmux/Query/Plan.rakumod","lib/LibTmux/Selection.rakumod","lib/LibTmux/Server.rakumod","lib/LibTmux/Transport.rakumod","lib/LibTmux/Types.rakumod","resources/catalogue.json","t/fixtures/format/captured-tokens.json","t/fixtures/format/layouts.json","t/lib/Test/LibTmux/Fixture.rakumod","t/lib/Test/LibTmux/Terminal.rakumod","t/unit/batch.rakutest","t/unit/catalogue.rakutest","t/unit/client.rakutest","t/unit/command.rakutest","t/unit/commands.rakutest","t/unit/configuration.rakutest","t/unit/control.rakutest","t/unit/engine.rakutest","t/unit/format.rakutest","t/unit/layout.rakutest","t/unit/model.rakutest","t/unit/plan.rakutest","t/unit/query.rakutest","t/unit/selection.rakutest","t/unit/server.rakutest","t/unit/transport.rakutest","t/unit/types.rakutest","tools/catalogue.raku","tools/check-examples.raku","tools/check-install.raku","tools/check-release.raku","tools/check-source.raku","tools/ci-matrix.raku","tools/export-docs.raku","tools/publish-github-release.sh","tools/release-retry.sh","xt/docs/export.rakutest","xt/github-release.rakutest","xt/live/batch.rakutest","xt/live/client.rakutest","xt/live/command.rakutest","xt/live/commands.rakutest","xt/live/configuration.rakutest","xt/live/control-no-start.rakutest","xt/live/control.rakutest","xt/live/engine.rakutest","xt/live/fixture.rakutest","xt/live/format.rakutest","xt/live/model.rakutest","xt/live/plan.rakutest","xt/live/query.rakutest","xt/live/server.rakutest","xt/live/transport.rakutest","xt/live/workload.rakutest","xt/meta.rakutest","xt/release-archive.rakutest","xt/release-retry.rakutest","xt/release.rakutest"]}
diff --git a/site/src/data/core-home.json b/site/src/data/core-home.json
index 4401948c7..2ae20532d 100644
--- a/site/src/data/core-home.json
+++ b/site/src/data/core-home.json
@@ -447,5 +447,28 @@
     "objectDescriptions": {
       "window": "A physical tmux window; session membership uses window links"
     }
+  },
+  "raku": {
+    "objects": {
+      "server": "LibTmux::Server",
+      "session": "LibTmux::Model::Session",
+      "window": "LibTmux::Model::Window",
+      "pane": "LibTmux::Model::Pane"
+    },
+    "association": "LibTmux::Model::WindowLink",
+    "capabilities": {
+      "objects": "LibTmux::Model::Pane",
+      "ids": "LibTmux::Model::Pane.id",
+      "queries": "LibTmux::Model::PaneSelection.where",
+      "errors": "X::LibTmux::InvalidFilter",
+      "servers": "LibTmux::Server.start",
+      "traversal": "LibTmux::Server.snapshot",
+      "send-keys": "LibTmux::Model::PaneRef.send-keys",
+      "capture": "LibTmux::Model::PaneRef.capture",
+      "argv": "LibTmux::Server.command",
+      "version-gate": "X::LibTmux::Unsupported",
+      "control-mode": "LibTmux::Server.open-control-async",
+      "async": "LibTmux::Server.snapshot-async"
+    }
   }
 }
diff --git a/site/src/data/core-recordings/erlang.json b/site/src/data/core-recordings/erlang.json
index 27180f80f..6151725c5 100644
--- a/site/src/data/core-recordings/erlang.json
+++ b/site/src/data/core-recordings/erlang.json
@@ -2,7 +2,7 @@
   "generated": "scripts/gen-core-recording.mjs",
   "port": "erlang",
   "repo": "libtmux/libtmux-erlang",
-  "revision": "e858027b2b204c3e621b1f74e9419c9b71e3f2f5",
+  "revision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64",
   "sandbox": {
     "tmux": "tmux 3.8a",
     "erlang": "29.1.2",
@@ -78,7 +78,7 @@
               "tmux": "display-message -p -t $0: -F '#{session_id}\n#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\n0\t1794448261",
+              "stdout": "$0\n0\t1794633957",
               "stderr": ""
             },
             {
@@ -293,7 +293,7 @@
               "tmux": "display-message -p -t %2 -F '#{pane_id}\n#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_index}\t#{pane_pid}\t#{pane_width}\t#{window_id}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "%2\n0\t0\t\t30\t1\t1795457\t59\t@1",
+              "stdout": "%2\n0\t0\t\t30\t1\t1955728\t59\t@1",
               "stderr": ""
             },
             {
@@ -597,7 +597,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -629,7 +629,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             },
             {
@@ -693,7 +693,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -725,7 +725,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             }
           ],
@@ -1020,7 +1020,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -1052,7 +1052,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             },
             {
@@ -1116,7 +1116,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -1148,7 +1148,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             }
           ],
@@ -1318,7 +1318,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -1350,7 +1350,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             },
             {
@@ -1414,7 +1414,7 @@
               "tmux": "list-sessions -F '#{session_id}\t#{session_attached}\t#{session_created}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t0\t1794448261",
+              "stdout": "$0\t0\t1794633957",
               "stderr": ""
             },
             {
@@ -1446,7 +1446,7 @@
               "tmux": "list-panes -a -F '#{session_id}\t#{window_id}\t#{window_index}\t#{pane_id}\t#{pane_index}\t#{pane_active}\t#{pane_dead}\t#{pane_dead_status}\t#{pane_height}\t#{pane_pid}\t#{pane_width}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1795013\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1795126\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1795457\t40",
+              "stdout": "$0\t@0\t0\t%0\t0\t1\t0\t\t30\t1955557\t120\n$0\t@1\t1\t%1\t0\t1\t0\t\t30\t1955635\t79\n$0\t@1\t1\t%2\t1\t0\t0\t\t30\t1955728\t40",
               "stderr": ""
             }
           ],
diff --git a/site/src/data/core-recordings/perl.json b/site/src/data/core-recordings/perl.json
index d1fd28572..8fa91662c 100644
--- a/site/src/data/core-recordings/perl.json
+++ b/site/src/data/core-recordings/perl.json
@@ -2,7 +2,7 @@
   "generated": "scripts/gen-core-recording.mjs",
   "port": "perl",
   "repo": "libtmux/libtmux-perl",
-  "revision": "36b978c5eb6aa33873229046037e7d26136ca2cf",
+  "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
   "sandbox": {
     "tmux": "tmux 3.8a",
     "perl": "5.44.0",
@@ -63,7 +63,7 @@
               "tmux": "new-session -d -P -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:socket_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pid}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:start_time}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:version}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}' -s demo -- /usr/bin/perl -e 'exec {$ARGV[0]} @ARGV or exit 127' -- /bin/cat",
               "mutates": true,
               "exit": 0,
-              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1725070\t1794447747\t3.8a\t$0",
+              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1881045\t1794633388\t3.8a\t$0",
               "stderr": ""
             },
             {
@@ -79,7 +79,7 @@
               "tmux": "list-sessions -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_attached}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_created}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_name}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_path}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\t1794447747\t$0\tdemo\t/tmp/marked",
+              "stdout": "0\t1794633388\t$0\tdemo\t/tmp/marked",
               "stderr": ""
             },
             {
@@ -95,7 +95,7 @@
               "tmux": "list-panes -a -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_active}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_command}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:cursor_shape}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead_status}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_height}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}\t#{s|\\\\|\\\\\\\\|;s|…",
               "mutates": false,
               "exit": 0,
-              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1725072\thost\t80\t$0\t@0\t0",
+              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1881046\thost\t80\t$0\t@0\t0",
               "stderr": "",
               "shortened": true
             },
@@ -276,7 +276,7 @@
               "tmux": "split-window -d -P -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:socket_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pid}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:start_time}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:version}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}' -t %0 -h -- /usr/bin/perl -e 'exec {$ARGV[0]} @ARGV or exit 127' -- /bin/cat",
               "mutates": true,
               "exit": 0,
-              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1725070\t1794447747\t3.8a\t%1",
+              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1881045\t1794633388\t3.8a\t%1",
               "stderr": ""
             },
             {
@@ -292,7 +292,7 @@
               "tmux": "list-sessions -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_attached}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_created}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_name}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_path}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\t1794447747\t$0\tdemo\t/tmp/marked",
+              "stdout": "0\t1794633388\t$0\tdemo\t/tmp/marked",
               "stderr": ""
             },
             {
@@ -308,7 +308,7 @@
               "tmux": "list-panes -a -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_active}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_command}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:cursor_shape}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead_status}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_height}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}\t#{s|\\\\|\\\\\\\\|;s|…",
               "mutates": false,
               "exit": 0,
-              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1725072\thost\t40\t$0\t@0\t0\n0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1725719\thost\t39\t$0\t@0\t0",
+              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1881046\thost\t40\t$0\t@0\t0\n0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1881238\thost\t39\t$0\t@0\t0",
               "stderr": "",
               "shortened": true
             },
@@ -394,7 +394,7 @@
               "tmux": "new-window -d -P -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:socket_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pid}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:start_time}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:version}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:window_id}' -t $0: -n logs -- /usr/bin/perl -e 'exec {$ARGV[0]} @ARGV or exit 127' -- /bin/cat",
               "mutates": true,
               "exit": 0,
-              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1725070\t1794447747\t3.8a\t@1",
+              "stdout": "/tmp/tmp/libtmux-perl-fixture-AbC1/s\t1881045\t1794633388\t3.8a\t@1",
               "stderr": ""
             },
             {
@@ -410,7 +410,7 @@
               "tmux": "list-sessions -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_attached}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_created}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_name}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_path}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\t1794447747\t$0\tdemo\t/tmp/marked",
+              "stdout": "0\t1794633388\t$0\tdemo\t/tmp/marked",
               "stderr": ""
             },
             {
@@ -426,7 +426,7 @@
               "tmux": "list-panes -a -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_active}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_command}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:cursor_shape}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead_status}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_height}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}\t#{s|\\\\|\\\\\\\\|;s|…",
               "mutates": false,
               "exit": 0,
-              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1725072\thost\t40\t$0\t@0\t0\n0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1725719\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1726003\thost\t80\t$0\t@1\t1",
+              "stdout": "1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1881046\thost\t40\t$0\t@0\t0\n0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1881238\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1881422\thost\t80\t$0\t@1\t1",
               "stderr": "",
               "shortened": true
             },
@@ -615,7 +615,7 @@
               "tmux": "list-sessions -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_attached}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_created}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_name}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_path}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\t1794447747\t$0\tdemo\t/tmp/marked",
+              "stdout": "0\t1794633388\t$0\tdemo\t/tmp/marked",
               "stderr": ""
             },
             {
@@ -631,7 +631,7 @@
               "tmux": "list-panes -a -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_active}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_command}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:cursor_shape}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead_status}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_height}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}\t#{s|\\\\|\\\\\\\\|;s|…",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1725072\thost\t40\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1725719\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1726003\thost\t80\t$0\t@1\t1",
+              "stdout": "0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1881046\thost\t40\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1881238\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1881422\thost\t80\t$0\t@1\t1",
               "stderr": "",
               "shortened": true
             },
@@ -899,7 +899,7 @@
               "tmux": "list-sessions -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_attached}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_created}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_id}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_name}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:session_path}'",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\t1794447747\t$0\tdemo\t/tmp/marked",
+              "stdout": "0\t1794633388\t$0\tdemo\t/tmp/marked",
               "stderr": ""
             },
             {
@@ -915,7 +915,7 @@
               "tmux": "list-panes -a -F '#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_active}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_command}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_current_path}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:cursor_shape}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_dead_status}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_height}\t#{s|\\\\|\\\\\\\\|;s|\t|\\\\t|;s|\n|\\\\n|:pane_id}\t#{s|\\\\|\\\\\\\\|;s|…",
               "mutates": false,
               "exit": 0,
-              "stdout": "0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1725072\thost\t40\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1725719\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1726003\thost\t80\t$0\t@1\t1",
+              "stdout": "0\tcat\t/tmp/marked\tdefault\t0\t\t24\t%0\t0\t1881046\thost\t40\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%1\t1\t1881238\thost\t39\t$0\t@0\t0\n1\tcat\t/tmp/marked\tdefault\t0\t\t24\t%2\t0\t1881422\thost\t80\t$0\t@1\t1",
               "stderr": "",
               "shortened": true
             },
diff --git a/site/src/data/core-recordings/raku.json b/site/src/data/core-recordings/raku.json
new file mode 100644
index 000000000..f04c2bcd4
--- /dev/null
+++ b/site/src/data/core-recordings/raku.json
@@ -0,0 +1,712 @@
+{
+  "generated": "scripts/gen-core-recording.mjs",
+  "port": "raku",
+  "repo": "libtmux/libtmux-raku",
+  "revision": "9a9838047f1585c2c790b011cb708670999b7bdd",
+  "sandbox": {
+    "tmux": "tmux 3.8",
+    "raku": "2026.09",
+    "shell": "/bin/sh",
+    "rewritten": {
+      "socket": "libtmux-owned-AbC123",
+      "tmuxExecutable": "/usr/bin/tmux",
+      "tmpdir": "/tmp"
+    }
+  },
+  "capabilities": {
+    "typed-graph": {
+      "program": {
+        "file": "quickstart.raku",
+        "sha256": "4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5"
+      },
+      "stepMap": "hand-written",
+      "printed": [
+        "editor: 2 panes"
+      ],
+      "tmuxBefore": {
+        "sessions": [],
+        "windows": [],
+        "panes": []
+      },
+      "steps": [
+        {
+          "id": "start",
+          "label": "Server.start",
+          "anchor": "Server.start(",
+          "type": "Server",
+          "returned": {
+            "socket": "libtmux-owned-AbC123"
+          },
+          "commands": [
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "new-session -d -P -F LTM1-session-#{session_id} -s work -x 80 -y 24 -- 'exec cat'",
+              "mutates": true,
+              "exit": 0,
+              "stdout": "LTM1-session-$0",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"p\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 80,
+                "height": 24,
+                "active": true
+              }
+            ]
+          }
+        },
+        {
+          "id": "snapshot-before",
+          "label": "Server.snapshot",
+          "anchor": "my $before = $server.snapshot;",
+          "type": "Snapshot",
+          "returned": {
+            "panes": 1,
+            "sessions": 1,
+            "windows": 1
+          },
+          "commands": [
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-sessions -F 'LTM1\\011libtmux.format/v1:session:session:qa:none:id,name,windows-count,attached-count,created,activity,path,grouped,group-name\\011qa\\011#{session_id}\\011#{q/a:session_name}\\011#{session_windows}\\011#{session_attached}\\011#{session_created}\\011#{session_activity}\\011#{q/a:session_path}\\011#{session_grouped}\\011#{q/a:session_group}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:session:session:qa:none:id,name,windows-count,attached-count,created,activity,path,grouped,group-name\tqa\t$0\twork\t1\t0\t1794634589\t1794634589\t/tmp/marked\t0\t\tEND",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-windows -a -F 'LTM1\\011libtmux.format/v1:window-link:window-link:qa:none:session-id,window-id,index,active,last,activity,bell,silence\\011qa\\011#{session_id}\\011#{window_id}\\011#{window_index}\\011#{window_active}\\011#{window_last_flag}\\011#{window_activity_flag}\\011#{window_bell_flag}\\011#{window_silence_flag}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:window-link:window-link:qa:none:session-id,window-id,index,active,last,activity,bell,silence\tqa\t$0\t@0\t0\t1\t0\t0\t0\t0\tEND",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-windows -a -F 'LTM1\\011libtmux.format/v1:window:window:qa:none:id,name,width,height,panes-count,layout,visible-layout,zoomed,modal-pane-id\\011qa\\011#{window_id}\\011#{q/a:window_name}\\011#{window_width}\\011#{window_height}\\011#{window_panes}\\011#{q/a:window_layout}\\011#{q/a:window_visible_layout}\\011#{window_zoomed_flag}\\011#{window_modal_pane}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:window:window:qa:none:id,name,width,height,panes-count,layout,visible-layout,zoomed,modal-pane-id\tqa\t@0\tsh\t80\t24\t1\t\"{\\\"V\\\":2,\\\"L\\\":{\\\"t\\\":\\\"p\\\",\\\"w\\\":80,\\\"h\\\":24,\\\"x\\\":0,\\\"y\\\":0,\\\"a\\\":true,\\\"i\\\":0,\\\"I\\\":\\\"%0\\\"}}\"\t\"{\\\"V\\\":2,\\\"L\\\":{\\\"t\\\":\\\"p\\\",\\\"w\\\":80,\\\"h\\\":24,\\\"x\\\":0,\\\"y\\\":0,\\\"a\\\":true,\\\"i\\\":0,\\\"I\\\":\\\"%0\\\"}}\"\t0\t\tEND",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-panes -a -F 'LTM1\\011libtmux.format/v1:pane:pane:qa:none:id,window-id,index,active,width,height,left,top,pid,tty,title,current-command,current-path,start-command,start-path,dead,dead-status,dead-signal,dead-time,in-mode,mode,pipe,synchronized,floating,modal,x,y,z,command-running,command-status,at-top,at-bottom,at-left,at-right\\011qa\\011#{pane_id}\\011#{window_id}\\011#{pane_index}\\011#{pane_act…",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:pane:pane:qa:none:id,window-id,index,active,width,height,left,top,pid,tty,title,current-command,current-path,start-command,start-path,dead,dead-status,dead-signal,dead-time,in-mode,mode,pipe,synchronized,floating,modal,x,y,z,command-running,command-status,at-top,at-bottom,at-left,at-right\tqa\t%0\t@0\t0\t1\t80\t24\t0\t0\t2005202\t/dev/pts/19\thost\tcat\t/tmp/marked\t\"\\\"exe…",
+              "stderr": "",
+              "shortened": true
+            },
+            {
+              "role": "command",
+              "tmux": "list-clients -F 'LTM1\\011libtmux.format/v1:client:client:qa:none:name,session-id,session-name,tty,pid,width,height,created,activity,control-mode,read-only,terminal-name,key-table\\011qa\\011#{q/a:client_name}\\011#{session_id}\\011#{q/a:client_session}\\011#{q/a:client_tty}\\011#{client_pid}\\011#{client_width}\\011#{client_height}\\011#{client_created}\\011#{client_activity}\\011#{client_control_mode}\\011#{…",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": "",
+              "shortened": true
+            },
+            {
+              "role": "command",
+              "tmux": "list-sessions -f #{session_grouped} -F 'LTM1\\011libtmux.format/v1:session-group:grouped-session:qa:none:name,size,attached-count\\011qa\\011#{q/a:session_group}\\011#{session_group_size}\\011#{session_group_attached}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-buffers -F 'LTM1\\011libtmux.format/v1:buffer:buffer:qa:none:name,size,created,sample\\011qa\\011#{q/a:buffer_name}\\011#{buffer_size}\\011#{buffer_created}\\011#{q/a:buffer_sample}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"p\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 80,
+                "height": 24,
+                "active": true
+              }
+            ]
+          }
+        },
+        {
+          "id": "pane",
+          "label": "PaneSelection.single",
+          "anchor": "my $left = $before.panes.single.ref;",
+          "type": "PaneRef",
+          "returned": {
+            "id": "%0"
+          },
+          "commands": [],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"p\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 80,
+                "height": 24,
+                "active": true
+              }
+            ]
+          }
+        },
+        {
+          "id": "split",
+          "label": "PaneRef.split",
+          "anchor": "$left.split(",
+          "type": "PaneRef",
+          "returned": {
+            "id": "%1"
+          },
+          "commands": [
+            {
+              "role": "command",
+              "tmux": "split-window -P -F LTM1-pane-#{pane_id} -t %0 -h -d -- 'exec cat'",
+              "mutates": true,
+              "exit": 0,
+              "stdout": "LTM1-pane-%1",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"h\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"c\":[{\"t\":\"p\",\"w\":40,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"},{\"t\":\"p\",\"w\":39,\"h\":24,\"x\":41,\"y\":0,\"i\":1,\"I\":\"%1\"}]}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 40,
+                "height": 24,
+                "active": true
+              },
+              {
+                "window": "@0",
+                "id": "%1",
+                "command": "cat",
+                "left": 41,
+                "top": 0,
+                "width": 39,
+                "height": 24,
+                "active": false
+              }
+            ]
+          }
+        },
+        {
+          "id": "title-editor",
+          "label": "PaneRef.set-title",
+          "anchor": "$left.set-title('editor');",
+          "type": "void",
+          "returned": null,
+          "commands": [
+            {
+              "role": "command",
+              "tmux": "select-pane -t %0 -T editor",
+              "mutates": true,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"h\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"c\":[{\"t\":\"p\",\"w\":40,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"},{\"t\":\"p\",\"w\":39,\"h\":24,\"x\":41,\"y\":0,\"i\":1,\"I\":\"%1\"}]}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 40,
+                "height": 24,
+                "active": true
+              },
+              {
+                "window": "@0",
+                "id": "%1",
+                "command": "cat",
+                "left": 41,
+                "top": 0,
+                "width": 39,
+                "height": 24,
+                "active": false
+              }
+            ]
+          }
+        },
+        {
+          "id": "title-logs",
+          "label": "PaneRef.set-title",
+          "anchor": "$right.set-title('logs');",
+          "type": "void",
+          "returned": null,
+          "commands": [
+            {
+              "role": "command",
+              "tmux": "select-pane -t %1 -T logs",
+              "mutates": true,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"h\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"c\":[{\"t\":\"p\",\"w\":40,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"},{\"t\":\"p\",\"w\":39,\"h\":24,\"x\":41,\"y\":0,\"i\":1,\"I\":\"%1\"}]}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 40,
+                "height": 24,
+                "active": true
+              },
+              {
+                "window": "@0",
+                "id": "%1",
+                "command": "cat",
+                "left": 41,
+                "top": 0,
+                "width": 39,
+                "height": 24,
+                "active": false
+              }
+            ]
+          }
+        },
+        {
+          "id": "snapshot",
+          "label": "Server.snapshot",
+          "anchor": "my $after = $server.snapshot;",
+          "type": "Snapshot",
+          "returned": {
+            "panes": 2,
+            "sessions": 1,
+            "windows": 1
+          },
+          "commands": [
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-sessions -F 'LTM1\\011libtmux.format/v1:session:session:qa:none:id,name,windows-count,attached-count,created,activity,path,grouped,group-name\\011qa\\011#{session_id}\\011#{q/a:session_name}\\011#{session_windows}\\011#{session_attached}\\011#{session_created}\\011#{session_activity}\\011#{q/a:session_path}\\011#{session_grouped}\\011#{q/a:session_group}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:session:session:qa:none:id,name,windows-count,attached-count,created,activity,path,grouped,group-name\tqa\t$0\twork\t1\t0\t1794634589\t1794634589\t/tmp/marked\t0\t\tEND",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-windows -a -F 'LTM1\\011libtmux.format/v1:window-link:window-link:qa:none:session-id,window-id,index,active,last,activity,bell,silence\\011qa\\011#{session_id}\\011#{window_id}\\011#{window_index}\\011#{window_active}\\011#{window_last_flag}\\011#{window_activity_flag}\\011#{window_bell_flag}\\011#{window_silence_flag}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:window-link:window-link:qa:none:session-id,window-id,index,active,last,activity,bell,silence\tqa\t$0\t@0\t0\t1\t0\t0\t0\t0\tEND",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-windows -a -F 'LTM1\\011libtmux.format/v1:window:window:qa:none:id,name,width,height,panes-count,layout,visible-layout,zoomed,modal-pane-id\\011qa\\011#{window_id}\\011#{q/a:window_name}\\011#{window_width}\\011#{window_height}\\011#{window_panes}\\011#{q/a:window_layout}\\011#{q/a:window_visible_layout}\\011#{window_zoomed_flag}\\011#{window_modal_pane}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:window:window:qa:none:id,name,width,height,panes-count,layout,visible-layout,zoomed,modal-pane-id\tqa\t@0\tsh\t80\t24\t2\t\"{\\\"V\\\":2,\\\"L\\\":{\\\"t\\\":\\\"h\\\",\\\"w\\\":80,\\\"h\\\":24,\\\"x\\\":0,\\\"y\\\":0,\\\"c\\\":[{\\\"t\\\":\\\"p\\\",\\\"w\\\":40,\\\"h\\\":24,\\\"x\\\":0,\\\"y\\\":0,\\\"a\\\":true,\\\"i\\\":0,\\\"I\\\":\\\"%0\\\"},{\\\"t\\\":\\\"p\\\",\\\"w\\\":39,\\\"h\\\":24,\\\"x\\\":41,\\\"y\\\":0,\\\"i\\\":1,\\\"I\\\":\\\"%1\\\"}]}}\"\t\"{\\\"V\\\":2,\\\"L\\\":{\\\"t\\\":\\\"h\\\",\\\"w\\\":80,…",
+              "stderr": "",
+              "shortened": true
+            },
+            {
+              "role": "command",
+              "tmux": "list-panes -a -F 'LTM1\\011libtmux.format/v1:pane:pane:qa:none:id,window-id,index,active,width,height,left,top,pid,tty,title,current-command,current-path,start-command,start-path,dead,dead-status,dead-signal,dead-time,in-mode,mode,pipe,synchronized,floating,modal,x,y,z,command-running,command-status,at-top,at-bottom,at-left,at-right\\011qa\\011#{pane_id}\\011#{window_id}\\011#{pane_index}\\011#{pane_act…",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "LTM1\tlibtmux.format/v1:pane:pane:qa:none:id,window-id,index,active,width,height,left,top,pid,tty,title,current-command,current-path,start-command,start-path,dead,dead-status,dead-signal,dead-time,in-mode,mode,pipe,synchronized,floating,modal,x,y,z,command-running,command-status,at-top,at-bottom,at-left,at-right\tqa\t%0\t@0\t0\t1\t40\t24\t0\t0\t2005202\t/dev/pts/19\teditor\tcat\t/tmp/marked\t\"…",
+              "stderr": "",
+              "shortened": true
+            },
+            {
+              "role": "command",
+              "tmux": "list-clients -F 'LTM1\\011libtmux.format/v1:client:client:qa:none:name,session-id,session-name,tty,pid,width,height,created,activity,control-mode,read-only,terminal-name,key-table\\011qa\\011#{q/a:client_name}\\011#{session_id}\\011#{q/a:client_session}\\011#{q/a:client_tty}\\011#{client_pid}\\011#{client_width}\\011#{client_height}\\011#{client_created}\\011#{client_activity}\\011#{client_control_mode}\\011#{…",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": "",
+              "shortened": true
+            },
+            {
+              "role": "command",
+              "tmux": "list-sessions -f #{session_grouped} -F 'LTM1\\011libtmux.format/v1:session-group:grouped-session:qa:none:name,size,attached-count\\011qa\\011#{q/a:session_group}\\011#{session_group_size}\\011#{session_group_attached}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "command",
+              "tmux": "list-buffers -F 'LTM1\\011libtmux.format/v1:buffer:buffer:qa:none:name,size,created,sample\\011qa\\011#{q/a:buffer_name}\\011#{buffer_size}\\011#{buffer_created}\\011#{q/a:buffer_sample}\\011END'",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "-V",
+              "mutates": false,
+              "exit": 0,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            },
+            {
+              "role": "probe",
+              "tmux": "run-shell -C libtmux-probe-00000000000000000000000000000000=#{version}/#{pid}/#{start_time}",
+              "mutates": false,
+              "exit": 1,
+              "stdout": "",
+              "stderr": ""
+            }
+          ],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"h\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"c\":[{\"t\":\"p\",\"w\":40,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"},{\"t\":\"p\",\"w\":39,\"h\":24,\"x\":41,\"y\":0,\"i\":1,\"I\":\"%1\"}]}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 40,
+                "height": 24,
+                "active": true
+              },
+              {
+                "window": "@0",
+                "id": "%1",
+                "command": "cat",
+                "left": 41,
+                "top": 0,
+                "width": 39,
+                "height": 24,
+                "active": false
+              }
+            ]
+          }
+        },
+        {
+          "id": "selected",
+          "label": "PaneSelection.single",
+          "anchor": "my $editor = $after.panes.filter(",
+          "type": "Pane",
+          "returned": {
+            "id": "%0",
+            "title": "editor"
+          },
+          "commands": [],
+          "transient": [],
+          "tmux": {
+            "sessions": [
+              {
+                "id": "$0",
+                "name": "work"
+              }
+            ],
+            "windows": [
+              {
+                "session": "$0",
+                "id": "@0",
+                "index": 0,
+                "name": "sh",
+                "active": true,
+                "layout": "{\"V\":2,\"L\":{\"t\":\"h\",\"w\":80,\"h\":24,\"x\":0,\"y\":0,\"c\":[{\"t\":\"p\",\"w\":40,\"h\":24,\"x\":0,\"y\":0,\"a\":true,\"i\":0,\"I\":\"%0\"},{\"t\":\"p\",\"w\":39,\"h\":24,\"x\":41,\"y\":0,\"i\":1,\"I\":\"%1\"}]}}"
+              }
+            ],
+            "panes": [
+              {
+                "window": "@0",
+                "id": "%0",
+                "command": "cat",
+                "left": 0,
+                "top": 0,
+                "width": 40,
+                "height": 24,
+                "active": true
+              },
+              {
+                "window": "@0",
+                "id": "%1",
+                "command": "cat",
+                "left": 41,
+                "top": 0,
+                "width": 39,
+                "height": 24,
+                "active": false
+              }
+            ]
+          }
+        },
+        {
+          "id": "close",
+          "label": "Server.close",
+          "anchor": "LEAVE $server.close",
+          "type": "void",
+          "returned": null,
+          "commands": [],
+          "transient": [],
+          "stopsServer": true,
+          "tmux": {
+            "sessions": [],
+            "windows": [],
+            "panes": []
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/site/src/data/destination-evidence.json b/site/src/data/destination-evidence.json
index ee42b418a..d2d77f209 100644
--- a/site/src/data/destination-evidence.json
+++ b/site/src/data/destination-evidence.json
@@ -3434,7 +3434,7 @@
           "note": "a branch link names no release"
         }
       ],
-      "checkedAt": "2026-11-07",
+      "checkedAt": "2026-11-14",
       "entries": [
         "perl:repository"
       ]
@@ -3455,7 +3455,7 @@
           "note": "a branch link names no release"
         }
       ],
-      "checkedAt": "2026-11-07",
+      "checkedAt": "2026-11-14",
       "entries": [
         "perl:libtmux-workspace"
       ]
@@ -3476,7 +3476,7 @@
           "note": "a branch link names no release"
         }
       ],
-      "checkedAt": "2026-11-07",
+      "checkedAt": "2026-11-14",
       "entries": [
         "perl:LibTmux-Async"
       ]
@@ -3497,7 +3497,7 @@
           "note": "a branch link names no release"
         }
       ],
-      "checkedAt": "2026-11-07",
+      "checkedAt": "2026-11-14",
       "entries": [
         "perl:LibTmux"
       ]
@@ -3518,7 +3518,7 @@
           "note": "a branch link names no release"
         }
       ],
-      "checkedAt": "2026-11-07",
+      "checkedAt": "2026-11-14",
       "entries": [
         "perl:LibTmux-Workspace"
       ]
@@ -3649,6 +3649,48 @@
         "powershell:LibTmux.Workspace"
       ]
     },
+    {
+      "url": "https://github.com/libtmux/libtmux-raku",
+      "kinds": [
+        "source"
+      ],
+      "host": "github",
+      "ok": true,
+      "status": 200,
+      "requested": "https://github.com/libtmux/libtmux-raku",
+      "identity": "libtmux/libtmux-raku",
+      "versionChecks": [
+        {
+          "check": "unsupported",
+          "note": "a branch link names no release"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "raku:repository"
+      ]
+    },
+    {
+      "url": "https://github.com/libtmux/libtmux-raku/tree/master/lib",
+      "kinds": [
+        "source"
+      ],
+      "host": "github",
+      "ok": true,
+      "status": 200,
+      "requested": "https://github.com/libtmux/libtmux-raku/tree/master/lib",
+      "identity": "libtmux/libtmux-raku/lib",
+      "versionChecks": [
+        {
+          "check": "unsupported",
+          "note": "a branch link names no release"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "raku:LibTmux"
+      ]
+    },
     {
       "url": "https://github.com/libtmux/libtmux-rs",
       "kinds": [
@@ -4951,6 +4993,33 @@
         "elixir:libtmux"
       ]
     },
+    {
+      "url": "https://hex.pm/packages/libtmux_erlang",
+      "kinds": [
+        "package"
+      ],
+      "host": "hex",
+      "ok": true,
+      "status": 200,
+      "requested": "https://hex.pm/packages/libtmux_erlang",
+      "identity": "libtmux_erlang",
+      "version": "0.0.1",
+      "repository": "libtmux/libtmux-erlang",
+      "versionChecks": [
+        {
+          "version": "0.0.1",
+          "source": "libtmux/libtmux-erlang:apps/libtmux_erlang/src/libtmux_erlang.app.src",
+          "ports": [
+            "erlang"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "erlang:libtmux_erlang"
+      ]
+    },
     {
       "url": "https://hex.pm/packages/libtmux_mcp",
       "kinds": [
@@ -5781,6 +5850,169 @@
         "lua:libtmux-workspace"
       ]
     },
+    {
+      "url": "https://metacpan.org/dist/LibTmux",
+      "kinds": [
+        "package"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/release/LibTmux",
+      "identity": "LibTmux",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/core/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux"
+      ]
+    },
+    {
+      "url": "https://metacpan.org/dist/LibTmux-Async",
+      "kinds": [
+        "package"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/release/LibTmux-Async",
+      "identity": "LibTmux-Async",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/async/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux-Async"
+      ]
+    },
+    {
+      "url": "https://metacpan.org/dist/LibTmux-Workspace",
+      "kinds": [
+        "package"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/release/LibTmux-Workspace",
+      "identity": "LibTmux-Workspace",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/workspace/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux-Workspace",
+        "perl:libtmux-workspace"
+      ]
+    },
+    {
+      "url": "https://metacpan.org/pod/LibTmux",
+      "kinds": [
+        "api"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/module/LibTmux",
+      "identity": "LibTmux",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/core/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux"
+      ]
+    },
+    {
+      "url": "https://metacpan.org/pod/LibTmux::Async",
+      "kinds": [
+        "api"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/module/LibTmux::Async",
+      "identity": "LibTmux::Async",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/async/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux-Async"
+      ]
+    },
+    {
+      "url": "https://metacpan.org/pod/LibTmux::Workspace",
+      "kinds": [
+        "api"
+      ],
+      "host": "metacpan",
+      "ok": true,
+      "status": 200,
+      "requested": "https://fastapi.metacpan.org/v1/module/LibTmux::Workspace",
+      "identity": "LibTmux::Workspace",
+      "version": "0.003",
+      "repository": "libtmux/libtmux-perl",
+      "versionChecks": [
+        {
+          "version": "0.003",
+          "source": "libtmux/libtmux-perl:packages/workspace/Makefile.PL",
+          "ports": [
+            "perl"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "perl:LibTmux-Workspace"
+      ]
+    },
     {
       "url": "https://pkg.go.dev/github.com/libtmux/libtmux-go",
       "kinds": [
@@ -6369,6 +6601,33 @@
         "py:tmuxp"
       ]
     },
+    {
+      "url": "https://raku.land/zef:libtmux/LibTmux",
+      "kinds": [
+        "package"
+      ],
+      "host": "raku-land",
+      "ok": true,
+      "status": 200,
+      "requested": "https://raku.land/zef:libtmux/LibTmux",
+      "identity": "LibTmux:auth<zef:libtmux>",
+      "version": "0.0.1",
+      "repository": "libtmux/libtmux-raku",
+      "versionChecks": [
+        {
+          "version": "0.0.1",
+          "source": "libtmux/libtmux-raku:META6.json",
+          "ports": [
+            "raku"
+          ],
+          "check": "confirmed"
+        }
+      ],
+      "checkedAt": "2026-11-14",
+      "entries": [
+        "raku:LibTmux"
+      ]
+    },
     {
       "url": "https://rubygems.org/gems/libtmux",
       "kinds": [
diff --git a/site/src/data/example-sources.json b/site/src/data/example-sources.json
index a3193d6c4..8954bcd88 100644
--- a/site/src/data/example-sources.json
+++ b/site/src/data/example-sources.json
@@ -217,7 +217,7 @@
   },
   "perl/workspace:examples/workspace.pl": {
     "repository": "libtmux/libtmux-perl",
-    "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa",
+    "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
     "sha256": "6f0b49432880a956960fcc19c02fe1ed0c7eeb4f57f2131e17162c4ecb65fbf3",
     "content": "use v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Workspace;\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $workspace = LibTmux::Workspace->new(\n            config => {\n                schema   => 'libtmux.workspace/v1',\n                sessions => [\n                    {\n                        name    => 'workspace-example',\n                        windows => [\n                            {\n                                name   => 'api',\n                                cwd    => $root,\n                                layout => 'even-horizontal',\n                                panes  => [\n                                    {command => ['/bin/sleep', '120']},\n                                    {\n                                        command    => ['/bin/sleep', '120'],\n                                        horizontal => true\n                                    },\n                                ],\n                            }\n                        ],\n                    }\n                ],\n            }\n        );\n        die 'plan mutated state' if $workspace->plan->{mutates};\n        my $loaded = $workspace->load(server => $server);\n        die 'load failed'   unless $loaded->{status} eq 'loaded';\n        die 'panes missing' unless $server->snapshot->panes->count == 2;\n        die 'repeat did not skip'\n            unless $workspace->load(server => $server, existing => 'skip')\n            ->{skipped}->@* == 1;\n        say 'workspace load and repeat: ok';\n    }\n);\n"
   },
diff --git a/site/src/data/home-examples.json b/site/src/data/home-examples.json
index a1dab6c90..ce126b49c 100644
--- a/site/src/data/home-examples.json
+++ b/site/src/data/home-examples.json
@@ -690,8 +690,8 @@
   "perl": {
     "lang": "perl",
     "sourceRepository": "libtmux/libtmux-perl",
-    "sourceRevision": "36b978c5eb6aa33873229046037e7d26136ca2cf",
-    "sourceTree": "269782d0ba1403af082abe05736ade4e31b5aa53",
+    "sourceRevision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
+    "sourceTree": "ce5106dc71b51d688816194599e27a62db5a10e2",
     "program": "examples/quickstart.pl",
     "excerpt": {
       "startLine": 1,
@@ -708,11 +708,12 @@
       {
         "name": "scripts/lib/LibTmuxFixture.pm",
         "lang": "perl",
-        "code": "package LibTmuxFixture;\nuse v5.44;\nuse File::Temp qw(tempdir);\nuse File::Path qw(remove_tree);\nuse LibTmux::Server;\nuse Errno qw(ECHILD EINTR);\n\nsub _children ($pid) {\n    open my $in, '<', \"/proc/$pid/task/$pid/children\" or return ();\n    my $line = do { local $/; <$in> };\n    close $in;\n    return grep { length } split /\\s+/, $line;\n}\n\nsub _stamp ($pid) {\n    open my $in, '<', \"/proc/$pid/stat\" or return undef;\n    my $line = do { local $/; <$in> };\n    close $in;\n    return undef unless $line =~ /\\A[0-9]+ \\(.*\\) (.*)\\z/s;\n    my @fields = split /\\s+/, $1;\n    return $fields[19];\n}\n\nsub _tree ($pid, $owned, $order) {\n    return if exists $owned->{$pid};\n    my $stamp = _stamp($pid);\n    return unless defined $stamp;\n    $owned->{$pid} = $stamp;\n    push @$order, $pid;\n    _tree($_, $owned, $order) for _children($pid);\n}\n\nsub run ($class, $code, %args) {\n    my %allowed = map { $_ => true } qw(executable timeout max_output env);\n    die 'fixture selectors/configuration cannot be overridden'\n        if grep { !$allowed{$_} } keys %args;\n    my %baseline = map { $_ => true } _children($$);\n    my $root = tempdir('libtmux-perl-fixture-XXXX', TMPDIR => 1, CLEANUP => 0);\n    my $server = LibTmuxFixture::Server->new(\n        socket_path => \"$root/s\",\n        config_file => '/dev/null',\n        executable  => $ENV{LIBTMUX_TEST_TMUX} // 'tmux',\n        timeout     => 0.8,\n        %args\n    );\n    my ($result, $failure);\n    local $SIG{TERM} = sub { die 'fixture interrupted by TERM' };\n    local $SIG{INT}  = sub { die 'fixture interrupted by INT' };\n    try { $result = $code->($server, $root) } catch ($error) {\n        $failure = $error\n    }\n    my $cleanup_error;\n    {\n        local $SIG{TERM} = 'IGNORE';\n        local $SIG{INT}  = 'IGNORE';\n        try {\n            my (%owned, @order);\n            my $pid = $server->{fixture_pid};\n            if (!$pid && -S \"$root/s\") {\n                try {\n                    $pid = 0 +\n                        $server->cmd('display-message', '-p', '#{pid}')->stdout\n                }\n                catch ($error) {\n                    die $error\n                        unless ref($error)\n                        && $error->isa('LibTmux::X::NoServer')\n                }\n            }\n            _tree($pid, \\%owned, \\@order) if $pid;\n            if (-S \"$root/s\") {\n                try { $server->kill_server }\n                catch ($error) {\n                    die $error\n                        unless ref($error)\n                        && $error->isa('LibTmux::X::NoServer')\n                }\n            }\n\n       # This author fixture runs in an isolated test process. Preserve children\n       # that existed before its scope, including nested/borrowed fixtures.\n            _tree($_, \\%owned, \\@order)\n                for grep { !$baseline{$_} } _children($$);\n            for my $child (@order) {\n                my $stamp = _stamp($child);\n                kill 'KILL', $child\n                    if defined($stamp) && $stamp eq $owned{$child};\n            }\n            local $SIG{ALRM} = sub { die 'owned fixture child did not exit' };\n            alarm 1;\n            for my $child (@order) {\n                my $waited;\n                do { $waited = waitpid($child, 0) }\n                    while ($waited < 0 && $! == EINTR);\n                my $wait_error = 0 + $!;\n                my $stamp      = _stamp($child);\n                die 'owned fixture process remained after teardown'\n                    if defined($stamp) && $stamp eq $owned{$child};\n                die 'fixture child exit was not observed'\n                    if $waited < 0 && $wait_error != ECHILD;\n            }\n            alarm 0;\n        }\n        catch ($error) { alarm 0; $cleanup_error = $error }\n    }\n    remove_tree($root);\n    if (defined $failure) {\n        if (ref($failure) && $failure isa LibTmux::X::Creation) {\n            my $cause = $failure->cause;\n            warn \"fixture acquisition cause: $cause\\n\" if defined $cause;\n        }\n        warn \"fixture cleanup also failed: $cleanup_error\"\n            if defined $cleanup_error;\n        die $failure;\n    }\n    die $cleanup_error if defined $cleanup_error;\n    return $result;\n}\n\npackage LibTmuxFixture::Server;\nuse parent 'LibTmux::Server';\n\nsub new_session ($self, %args) {\n    my $session = $self->SUPER::new_session(%args);\n    $self->{fixture_pid} =\n        0 + $self->cmd('display-message', '-p', '#{pid}')->stdout\n        unless $self->{fixture_pid};\n    return $session;\n}\n1;\n"
+        "code": "package LibTmuxFixture;\nuse v5.44;\nuse File::Temp qw(tempdir);\nuse File::Path qw(remove_tree);\nuse LibTmux::Server;\nuse Errno qw(ECHILD EINTR);\n\nsub _children ($pid) {\n    open my $in, '<', \"/proc/$pid/task/$pid/children\" or return ();\n    my $line = do { local $/; <$in> };\n    close $in;\n    return grep { length } split /\\s+/, $line;\n}\n\nsub _stamp ($pid) {\n    open my $in, '<', \"/proc/$pid/stat\" or return undef;\n    my $line = do { local $/; <$in> };\n    close $in;\n    return undef unless $line =~ /\\A[0-9]+ \\(.*\\) (.*)\\z/s;\n    my @fields = split /\\s+/, $1;\n    return $fields[19];\n}\n\nsub _tree ($pid, $owned, $order) {\n    return if exists $owned->{$pid};\n    my $stamp = _stamp($pid);\n    return unless defined $stamp;\n    $owned->{$pid} = $stamp;\n    push @$order, $pid;\n    _tree($_, $owned, $order) for _children($pid);\n}\n\nsub run ($class, $code, %args) {\n    my %allowed = map { $_ => true } qw(executable timeout max_output env);\n    die 'fixture selectors/configuration cannot be overridden'\n        if grep { !$allowed{$_} } keys %args;\n    my %baseline = map { $_ => true } _children($$);\n    my $root = tempdir('libtmux-perl-fixture-XXXX', TMPDIR => 1, CLEANUP => 0);\n    my $server = LibTmuxFixture::Server->new(\n        socket_path => \"$root/s\",\n        config_file => '/dev/null',\n        executable  => $ENV{LIBTMUX_TEST_TMUX} // 'tmux',\n        timeout     => 0.8,\n        %args\n    );\n    my ($result, $failure);\n    local $SIG{TERM} = sub { die 'fixture interrupted by TERM' };\n    local $SIG{INT}  = sub { die 'fixture interrupted by INT' };\n    try { $result = $code->($server, $root) } catch ($error) {\n        $failure = $error\n    }\n    my @cleanup_errors;\n    {\n        local $SIG{TERM} = 'IGNORE';\n        local $SIG{INT}  = 'IGNORE';\n        try {\n            my (%owned, @order);\n            my $pid = $server->{fixture_pid};\n            if (!$pid && -S \"$root/s\") {\n                try {\n                    $pid = 0 +\n                        $server->cmd('display-message', '-p', '#{pid}')->stdout\n                }\n                catch ($error) {\n                    push @cleanup_errors, $error\n                        unless ref($error)\n                        && $error->isa('LibTmux::X::NoServer')\n                }\n            }\n            _tree($pid, \\%owned, \\@order) if $pid;\n            if (-S \"$root/s\") {\n                try { $server->kill_server }\n                catch ($error) {\n                    push @cleanup_errors, $error\n                        unless ref($error)\n                        && $error->isa('LibTmux::X::NoServer')\n                }\n            }\n\n       # This author fixture runs in an isolated test process. Preserve children\n       # that existed before its scope, including nested/borrowed fixtures.\n            _tree($_, \\%owned, \\@order)\n                for grep { !$baseline{$_} } _children($$);\n            for my $child (@order) {\n                my $stamp = _stamp($child);\n                kill 'KILL', $child\n                    if defined($stamp) && $stamp eq $owned{$child};\n            }\n            local $SIG{ALRM} = sub { die 'owned fixture child did not exit' };\n            alarm 1;\n            for my $child (@order) {\n                my $waited;\n                do { $waited = waitpid($child, 0) }\n                    while ($waited < 0 && $! == EINTR);\n                my $wait_error = 0 + $!;\n                my $stamp      = _stamp($child);\n                die 'owned fixture process remained after teardown'\n                    if defined($stamp) && $stamp eq $owned{$child};\n                die 'fixture child exit was not observed'\n                    if $waited < 0 && $wait_error != ECHILD;\n            }\n            alarm 0;\n        }\n        catch ($error) { alarm 0; push @cleanup_errors, $error }\n    }\n    try {\n        my $errors;\n        remove_tree($root, {error => \\$errors});\n        for my $entry (@$errors) {\n            push @cleanup_errors,\n                map { \"remove fixture $_: $entry->{$_}\" } sort keys %$entry;\n        }\n    }\n    catch ($error) { push @cleanup_errors, $error }\n    $failure = shift @cleanup_errors\n        if !defined($failure) && @cleanup_errors;\n    if (defined $failure) {\n        my $reported = $failure;\n        if (ref($failure) && $failure isa LibTmux::X::Creation) {\n            my $cause = $failure->cause;\n            warn \"fixture acquisition cause: $cause\\n\" if defined $cause;\n            $reported = $cause                         if defined $cause;\n        }\n        if (ref($reported) && $reported isa LibTmux::X) {\n            if (my $result = $reported->result) {\n                my $dispatched     = $reported->dispatched;\n                my $dispatch_state = 'unknown';\n                $dispatch_state = $dispatched ? 'yes' : 'no'\n                    if defined $dispatched;\n                warn 'fixture process outcome: dispatched='\n                    . $dispatch_state\n                    . ' raw_status='\n                    . ($result->raw_status // 'unknown')\n                    . ' stdout_bytes='\n                    . length($result->stdout // '')\n                    . ' stderr_bytes='\n                    . length($result->stderr // '') . \"\\n\";\n            }\n        }\n        warn \"fixture cleanup also failed: $_\" for @cleanup_errors;\n        die $failure;\n    }\n    return $result;\n}\n\npackage LibTmuxFixture::Server;\nuse parent 'LibTmux::Server';\n\nsub new_session ($self, %args) {\n    my $session = $self->SUPER::new_session(%args);\n    $self->{fixture_pid} =\n        0 + $self->cmd('display-message', '-p', '#{pid}')->stdout\n        unless $self->{fixture_pid};\n    return $session;\n}\n1;\n"
       }
     ],
-    "prerequisites": "Linux x86_64 LP64, Perl 5.44.0, tmux 3.3a or newer, and the LibTmux core distribution installed from source. Save both files with the displayed directories. No CPAN release is claimed.",
+    "prerequisites": "Linux x86_64 LP64, Perl 5.44.0, cpm, tmux 3.3a or newer and access to CPAN. Save both files with the displayed directories.",
     "commands": [
+      "cpm install \\\n    --global \\\n    'LibTmux~>= 0.003'",
       "perl examples/quickstart.pl"
     ],
     "expectedOutput": "session demo\n  window 0:editor: %0 %1\n  window 1:logs: %2\n%1 is in window editor\n",
@@ -795,8 +796,8 @@
   "erlang": {
     "lang": "erlang",
     "sourceRepository": "libtmux/libtmux-erlang",
-    "sourceRevision": "e858027b2b204c3e621b1f74e9419c9b71e3f2f5",
-    "sourceTree": "0e5cf4b98920e44500a7ae8f3be5d8a88fae443f",
+    "sourceRevision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64",
+    "sourceTree": "418f84b74d1be2f7e961d7392a5d66e8e0c47e6d",
     "program": "src/readme_demo.erl",
     "excerpt": {
       "startLine": 1,
@@ -813,7 +814,7 @@
       {
         "name": "rebar.config",
         "lang": "erlang",
-        "code": "{minimum_otp_vsn, \"29.1.2\"}.\n{erl_opts, [debug_info, warnings_as_errors]}.\n{deps, [\n    {libtmux_erlang, {git_subdir,\n        \"https://github.com/libtmux/libtmux-erlang.git\",\n        {ref, \"e858027b2b204c3e621b1f74e9419c9b71e3f2f5\"}, \"apps/libtmux_erlang\"}}\n]}.\n"
+        "code": "{minimum_otp_vsn, \"29.1.2\"}.\n{erl_opts, [debug_info, warnings_as_errors]}.\n{deps, [\n    {libtmux_erlang, \"~> 0.0.1\"}\n]}.\n"
       },
       {
         "name": "src/tmux_example.app.src",
@@ -821,10 +822,10 @@
         "code": "{application, tmux_example, [\n    {vsn, \"0.1.0\"},\n    {applications, [kernel, stdlib, libtmux_erlang]},\n    {modules, []}\n]}.\n"
       }
     ],
-    "prerequisites": "Linux, tmux 3.3a–3.8, Erlang/OTP 29.1.2, Rebar3 3.28.0, Git, make and a C11 compiler. Save the displayed files in an empty project directory.",
+    "prerequisites": "Linux, tmux 3.3a–3.8, Erlang/OTP 29.1.2, Rebar3 3.28.0, make, a C11 compiler and access to hex.pm. Save the displayed files in an empty project directory.",
     "commands": [
       "rebar3 compile",
-      "env \\\n    -u TMUX \\\n    -u TMUX_PANE \\\n    erl \\\n    -noshell \\\n    -pa _build/default/lib/tmux_example/ebin \\\n    -pa _build/default/lib/libtmux_erlang/apps/libtmux_erlang/ebin \\\n    -eval '\n        {ok, _} = application:ensure_all_started(libtmux_erlang),\n        Tmux = unicode:characters_to_binary(os:find_executable(\"tmux\")),\n        Stats = readme_demo:run(Tmux),\n        io:format(\"~B session, ~B windows, ~B panes; ~B matches~n\", [\n            maps:get(sessions, Stats), maps:get(windows, Stats),\n            maps:get(panes, Stats), maps:get(matched_panes, Stats)]),\n        halt().'"
+      "env \\\n    -u TMUX \\\n    -u TMUX_PANE \\\n    erl \\\n    -noshell \\\n    -pa _build/default/lib/tmux_example/ebin \\\n    -pa _build/default/lib/libtmux_erlang/ebin \\\n    -eval '\n        {ok, _} = application:ensure_all_started(libtmux_erlang),\n        Tmux = unicode:characters_to_binary(os:find_executable(\"tmux\")),\n        Stats = readme_demo:run(Tmux),\n        io:format(\"~B session, ~B windows, ~B panes; ~B matches~n\", [\n            maps:get(sessions, Stats), maps:get(windows, Stats),\n            maps:get(panes, Stats), maps:get(matched_panes, Stats)]),\n        halt().'"
     ],
     "expectedOutput": "1 session, 2 windows, 3 panes; 2 matches\n",
     "variants": {
@@ -833,5 +834,38 @@
       "cleanup": "-module(readme_demo).\n-moduledoc \"Create a workspace, query its graph and preserve captured values.\".\n-export([run/1]).\n-import_record(tmux_model, [pane]).\n\n-spec run(binary()) -> map().\nrun(Executable) ->\n    Options = #{executable => Executable},\n    {ok, Result} = tmux_server:with_owned(Options, fun(Server) ->\n        {ok, Session} = tmux_session:create(Server, #{name => <<\"workspace\">>,\n            window_name => <<\"editor\">>, width => 120, height => 30,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Worker} = tmux_window:create(Session,\n            #{name => <<\"workers\">>,\n              launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Right} = tmux_pane:split(Worker, #{direction => horizontal,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, _} = tmux_window:select_layout(Worker, even_horizontal),\n        {ok, _} = tmux_pane:resize(Right, #{width => 40}),\n        {ok, Snapshot} = tmux_server:snapshot(Server),\n        Windows = tmux_select:windows(Snapshot),\n        Workers = #{name => <<\"workers\">>, panes => #{count => 2,\n            every => #{current_command => <<\"cat\">>}}},\n        {ok, Captured} = tmux_select:one(Workers, Windows),\n        {ok, Children} = tmux_snapshot:related(panes, Captured, Snapshot),\n        Ids = [Id || #pane{id = Id} <:- Children],\n        2 = length(Ids),\n        Criteria = #{width => #{gte => 20},\n            window => #{is => #{name => <<\"workers\">>}}},\n        Query = tmux_query:where(Criteria, tmux_query:panes(Server)),\n        {ok, Fetched} = tmux_query:fetch(Query),\n        2 = tmux_select:size(Fetched),\n        {ok, _} = tmux_window:rename(Worker, <<\"finished\">>),\n        <<\"workers\">> = tmux_model:get(name, Captured),\n        {ok, Fresh} = tmux_query:fetch(tmux_query:where(\n            #{name => <<\"finished\">>}, tmux_query:windows(Server))),\n        {ok, Renamed} = tmux_select:one(Fresh),\n        <<\"finished\">> = tmux_model:get(name, Renamed),\n        1 = length(tmux_snapshot:sessions(Snapshot)),\n        2 = length(tmux_snapshot:windows(Snapshot)),\n        3 = length(tmux_snapshot:panes(Snapshot)),\n        #{sessions => 1, windows => 2, panes => 3, matched_panes => 2,\n          captured_name => <<\"workers\">>, immutable => true}\n    end),\n    Result.\n"
     },
     "singleView": "The program runs inside tmux_server:with_owned/2, which retires its owned server when the function finishes, so there are no lifecycle variants to select."
+  },
+  "raku": {
+    "lang": "raku",
+    "sourceRepository": "libtmux/libtmux-raku",
+    "sourceRevision": "9a9838047f1585c2c790b011cb708670999b7bdd",
+    "sourceTree": "8e2aec2ca4319d834066c1ef7fbea50eaa60e998",
+    "capability": "typed-graph",
+    "singleView": "This complete program owns a private tmux server and closes it with LEAVE when the program exits, including on an exception.",
+    "program": "quickstart.raku",
+    "excerpt": {
+      "startLine": 1,
+      "endLine": 14,
+      "dedent": 0,
+      "importsEndLine": 1
+    },
+    "prerequisites": "Linux, Raku 6.d with zef, and tmux 3.3a through 3.8 on PATH. The first command installs the published LibTmux distribution from Raku Land, so it needs network access to the zef ecosystem. The program starts its own private tmux server.",
+    "commands": [
+      "zef install 'LibTmux:ver<0.0.1+>:auth<zef:libtmux>'",
+      "raku quickstart.raku"
+    ],
+    "expectedOutput": "editor: 2 panes\n",
+    "files": [
+      {
+        "name": "quickstart.raku",
+        "lang": "raku",
+        "code": "use LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n"
+      }
+    ],
+    "variants": {
+      "concise": "use LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n",
+      "errors": "use LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n",
+      "cleanup": "use LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n"
+    }
   }
 }
diff --git a/site/src/data/manifest-packages.json b/site/src/data/manifest-packages.json
index 51e755cbe..c3d658580 100644
--- a/site/src/data/manifest-packages.json
+++ b/site/src/data/manifest-packages.json
@@ -142,14 +142,14 @@
     },
     "erlang": {
       "repo": "libtmux/libtmux-erlang",
-      "revision": "f1a2e66c0fa15d1e8d4efa2725a159121815293b",
+      "revision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64",
       "distributions": [
         {
           "name": "libtmux_erlang",
-          "version": "0.0.0+development",
+          "version": "0.0.1",
           "manifest": "apps/libtmux_erlang/src/libtmux_erlang.app.src",
           "repo": "libtmux/libtmux-erlang",
-          "revision": "f1a2e66c0fa15d1e8d4efa2725a159121815293b"
+          "revision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64"
         }
       ],
       "units": []
@@ -951,28 +951,28 @@
     },
     "perl": {
       "repo": "libtmux/libtmux-perl",
-      "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa",
+      "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
       "distributions": [
         {
           "name": "LibTmux",
-          "version": "0.001_001",
+          "version": "0.003",
           "manifest": "packages/core/Makefile.PL",
           "repo": "libtmux/libtmux-perl",
-          "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa"
+          "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69"
         },
         {
           "name": "LibTmux-Async",
-          "version": "0.001_001",
+          "version": "0.003",
           "manifest": "packages/async/Makefile.PL",
           "repo": "libtmux/libtmux-perl",
-          "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa"
+          "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69"
         },
         {
           "name": "LibTmux-Workspace",
-          "version": "0.001_001",
+          "version": "0.003",
           "manifest": "packages/workspace/Makefile.PL",
           "repo": "libtmux/libtmux-perl",
-          "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa"
+          "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69"
         }
       ],
       "units": [
@@ -983,6 +983,20 @@
           "file": true
         }
       ]
+    },
+    "raku": {
+      "repo": "libtmux/libtmux-raku",
+      "revision": "8293da87dc45f61ea2a68d1cc5327b4e62892732",
+      "distributions": [
+        {
+          "name": "LibTmux",
+          "version": "0.0.1",
+          "manifest": "META6.json",
+          "repo": "libtmux/libtmux-raku",
+          "revision": "8293da87dc45f61ea2a68d1cc5327b4e62892732"
+        }
+      ],
+      "units": []
     }
   }
 }
diff --git a/site/src/data/mentions.json b/site/src/data/mentions.json
index 90f676595..d2106ec0e 100644
--- a/site/src/data/mentions.json
+++ b/site/src/data/mentions.json
@@ -3780,6 +3780,13 @@
    "title": "Native API documentation",
    "section": "guides"
   },
+  {
+   "port": "erlang",
+   "symbol": "tmux_query",
+   "page": "/erlang/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "erlang",
    "symbol": "tmux_query:explain/1",
@@ -3843,6 +3850,13 @@
    "title": "Native API documentation",
    "section": "guides"
   },
+  {
+   "port": "erlang",
+   "symbol": "tmux_select",
+   "page": "/erlang/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "erlang",
    "symbol": "tmux_select:filter/2",
@@ -3878,6 +3892,13 @@
    "title": "Native API documentation",
    "section": "guides"
   },
+  {
+   "port": "erlang",
+   "symbol": "tmux_server",
+   "page": "/erlang/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "erlang",
    "symbol": "tmux_server:bind/2",
@@ -4053,6 +4074,13 @@
    "title": "Native API documentation",
    "section": "guides"
   },
+  {
+   "port": "erlang",
+   "symbol": "tmux_snapshot",
+   "page": "/erlang/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "erlang",
    "symbol": "tmux_snapshot:metadata/1",
@@ -12481,6 +12509,13 @@
    "title": "Filtering",
    "section": "guides"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Filter",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Pane::cursor_shape",
@@ -12490,25 +12525,32 @@
   },
   {
    "port": "perl",
-   "symbol": "LibTmux::Selection::exists",
-   "page": "/perl/latest/guides/filtering/",
-   "title": "Filtering",
+   "symbol": "LibTmux::Selection",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
    "section": "guides"
   },
   {
    "port": "perl",
-   "symbol": "LibTmux::Selection::first",
+   "symbol": "LibTmux::Selection::exists",
    "page": "/perl/latest/guides/filtering/",
    "title": "Filtering",
    "section": "guides"
   },
   {
    "port": "perl",
-   "symbol": "LibTmux::Selection::grep",
+   "symbol": "LibTmux::Selection::first",
    "page": "/perl/latest/examples/programs/",
    "title": "Runnable programs",
    "section": "examples"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Selection::first",
+   "page": "/perl/latest/guides/filtering/",
+   "title": "Filtering",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Selection::grep",
@@ -12516,6 +12558,13 @@
    "title": "Filtering",
    "section": "guides"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Selection::grep",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Selection::iterator",
@@ -12530,6 +12579,20 @@
    "title": "Snapshot graph and identity",
    "section": "concepts"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Selection::one",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Selection::one_or_undef",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Selection::one_or_undef",
@@ -12546,10 +12609,10 @@
   },
   {
    "port": "perl",
-   "symbol": "LibTmux::Selection::where",
-   "page": "/perl/latest/examples/programs/",
-   "title": "Runnable programs",
-   "section": "examples"
+   "symbol": "LibTmux::Selection::to_array",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
   },
   {
    "port": "perl",
@@ -12558,12 +12621,19 @@
    "title": "Filtering",
    "section": "guides"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Selection::where",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server",
-   "page": "/perl/latest/examples/orchestration/",
-   "title": "Create sessions, windows, and panes",
-   "section": "examples"
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
   },
   {
    "port": "perl",
@@ -12586,6 +12656,13 @@
    "title": "Create sessions, windows, and panes",
    "section": "examples"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::capture_pane",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server::cmd",
@@ -12621,6 +12698,27 @@
    "title": "Snapshot graph and identity",
    "section": "concepts"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::new_session",
+   "page": "/perl/latest/examples/orchestration/",
+   "title": "Create sessions, windows, and panes",
+   "section": "examples"
+  },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::new_session",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::new_session",
+   "page": "/perl/latest/guides/installation/",
+   "title": "Installation",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server::query_panes",
@@ -12635,6 +12733,13 @@
    "title": "Create sessions, windows, and panes",
    "section": "examples"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::send_keys",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server::send_text",
@@ -12642,6 +12747,13 @@
    "title": "Create sessions, windows, and panes",
    "section": "examples"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::send_text",
+   "page": "/perl/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server::set_option",
@@ -12649,6 +12761,20 @@
    "title": "Create sessions, windows, and panes",
    "section": "examples"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::snapshot",
+   "page": "/perl/latest/examples/orchestration/",
+   "title": "Create sessions, windows, and panes",
+   "section": "examples"
+  },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::Server::snapshot",
+   "page": "/perl/latest/guides/installation/",
+   "title": "Installation",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::Server::unset_option",
@@ -12719,6 +12845,13 @@
    "title": "Live query planning",
    "section": "topics"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::X::expected",
+   "page": "/perl/latest/topics/errors/",
+   "title": "Errors and recovery",
+   "section": "topics"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::X::InvalidSelection",
@@ -12726,6 +12859,13 @@
    "title": "Snapshot graph and identity",
    "section": "concepts"
   },
+  {
+   "port": "perl",
+   "symbol": "LibTmux::X::NoServer",
+   "page": "/perl/latest/guides/installation/",
+   "title": "Installation",
+   "section": "guides"
+  },
   {
    "port": "perl",
    "symbol": "LibTmux::X::QueryMismatch",
@@ -14469,6 +14609,76 @@
    "title": "Python workspace internal API",
    "section": "ports"
   },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Capabilities.status",
+   "page": "/raku/latest/examples/programs/",
+   "title": "Runnable programs",
+   "section": "examples"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Capabilities.status",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Model::PaneRef.send-keys",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Model::PaneRef.send-text",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Complete",
+   "page": "/raku/latest/examples/programs/",
+   "title": "Runnable programs",
+   "section": "examples"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Complete",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Failed",
+   "page": "/raku/latest/examples/programs/",
+   "title": "Runnable programs",
+   "section": "examples"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Failed",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Skipped",
+   "page": "/raku/latest/examples/programs/",
+   "title": "Runnable programs",
+   "section": "examples"
+  },
+  {
+   "port": "raku",
+   "symbol": "LibTmux::Types::Outcome.Skipped",
+   "page": "/raku/latest/guides/getting-started/",
+   "title": "Getting started",
+   "section": "guides"
+  },
   {
    "port": "rs",
    "symbol": "client.Client",
diff --git a/site/src/data/perl-pod.json b/site/src/data/perl-pod.json
new file mode 100644
index 000000000..a90590e2c
--- /dev/null
+++ b/site/src/data/perl-pod.json
@@ -0,0 +1,612 @@
+{
+  "schema": 1,
+  "distributions": {
+    "LibTmux": {
+      "author": "TONY",
+      "release": "0.003",
+      "documents": {
+        "LibTmux": {
+          "path": "lib/LibTmux.pm",
+          "sha256": "da7690215acae3f9a4f2d5aeb6ef1785d2b5f0f84718fd130bca4666c8e908c9",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION",
+            "DOCUMENTATION"
+          ]
+        },
+        "LibTmux::Client": {
+          "path": "lib/LibTmux/Client.pm",
+          "sha256": "1d6a7fe38802d134215f476727e014cceb7f189d608a45e907aa74a9b33377a3",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "height",
+            "id",
+            "name",
+            "pid",
+            "session",
+            "tty",
+            "width",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::ClientSelection": {
+          "path": "lib/LibTmux/ClientSelection.pm",
+          "sha256": "24c200afefcb28a5df984b99db8df4253986176b005daf175ecd3f45ebc50aab",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION"
+          ]
+        },
+        "LibTmux::Codec": {
+          "path": "lib/LibTmux/Codec.pm",
+          "sha256": "c3517cd3542e7622b575ddf3a8274841e43df843d4b9b4739d79268ed047a327",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION",
+            "METHODS",
+            "format",
+            "decode"
+          ]
+        },
+        "LibTmux::CommandResult": {
+          "path": "lib/LibTmux/CommandResult.pm",
+          "sha256": "c05fee72a809d924d96908eeb5c9d4c328b088d5e4f9692f292f9c96b13fdbd9",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "stdout",
+            "stderr",
+            "exit_code",
+            "signal",
+            "raw_status",
+            "success",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::Entity": {
+          "path": "lib/LibTmux/Entity.pm",
+          "sha256": "46fbe507850d5880f59d78a732270e2554d5e4fe112d8a8013e60a9fca0d5c20",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION",
+            "METHODS",
+            "kind",
+            "server_id",
+            "generation",
+            "identity",
+            "to_record",
+            "EXECUTION"
+          ]
+        },
+        "LibTmux::Filter": {
+          "path": "lib/LibTmux/Filter.pm",
+          "sha256": "fa3b65a22515a6086d06f044e06eeb454575b926e41216419f445d084c8cd8bc",
+          "anchors": [
+            "NAME",
+            "SYNOPSIS",
+            "CONTRACT",
+            "METHODS",
+            "new",
+            "entity",
+            "normalized_where",
+            "matches",
+            "register_adapter",
+            "to_data",
+            "to_json",
+            "from_data",
+            "from_json",
+            "EXECUTION"
+          ]
+        },
+        "LibTmux::Operation": {
+          "path": "lib/LibTmux/Operation.pm",
+          "sha256": "dc63406ae06d858fad89347a146cb7ba8496e6db9ee5eaf1ab278e2a67d250e3",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "request",
+            "value",
+            "then",
+            "catch",
+            "sequence",
+            "run"
+          ]
+        },
+        "LibTmux::Pane": {
+          "path": "lib/LibTmux/Pane.pm",
+          "sha256": "1d34d763df3256c8645b91395788d0e863e1bff80115a473494b23c4525f3040",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "active",
+            "current_command",
+            "current_path",
+            "cursor_shape",
+            "dead",
+            "exit_status",
+            "height",
+            "id",
+            "index",
+            "pid",
+            "title",
+            "width",
+            "window",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::PaneSelection": {
+          "path": "lib/LibTmux/PaneSelection.pm",
+          "sha256": "6edb85943a642e56afcc5185b905c4fc82fcb9c3ca35d013aa61627421354fc5",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION"
+          ]
+        },
+        "LibTmux::ProcessJob": {
+          "path": "lib/LibTmux/ProcessJob.pm",
+          "sha256": "fd46908c18f4b034cd74b1c8e10b1525d7270e60159e32e6c45b0778425be642",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "start",
+            "pid",
+            "cleanup_complete",
+            "take_result_handle",
+            "consume",
+            "finish",
+            "cancel",
+            "wait"
+          ]
+        },
+        "LibTmux::QueryPlan": {
+          "path": "lib/LibTmux/QueryPlan.pm",
+          "sha256": "3f18a903100e46dcb58c32b7ad6a4853df8094f8932a56644b33d6e4dd5668fa",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "summary",
+            "to_data",
+            "filter",
+            "policy"
+          ]
+        },
+        "LibTmux::Schema": {
+          "path": "lib/LibTmux/Schema.pm",
+          "sha256": "69290dbf72abe7cb27d9364b519f261281088d59abd4c17af33026adf4d7a52f",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "register_adapter"
+          ]
+        },
+        "LibTmux::Selection": {
+          "path": "lib/LibTmux/Selection.pm",
+          "sha256": "12565d289dcb00e13852d297cbd843a65a9bab43c0e6cab6392bc6fdf8749c99",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "new",
+            "where",
+            "grep",
+            "count",
+            "exists",
+            "first",
+            "one",
+            "one_or_undef",
+            "iterator",
+            "to_array",
+            "EXECUTION"
+          ]
+        },
+        "LibTmux::Selection::Iterator": {
+          "path": "lib/LibTmux/Selection/Iterator.pm",
+          "sha256": "755aaf2aa31e3302422d00573bd4ce4d26be8017f1d008b12be1f64708496d40",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "next"
+          ]
+        },
+        "LibTmux::Server": {
+          "path": "lib/LibTmux/Server.pm",
+          "sha256": "2ee3f86b2a377d31692321c19928845f49463a6faa1e231bf4fadb5825be23ef",
+          "anchors": [
+            "NAME",
+            "SYNOPSIS",
+            "CONTRACT",
+            "ERRORS",
+            "METHODS",
+            "new",
+            "execute",
+            "cmd",
+            "new_session",
+            "new_window",
+            "split_pane",
+            "snapshot",
+            "listings",
+            "query_panes",
+            "explain_panes",
+            "rename_session",
+            "rename_window",
+            "link_window",
+            "unlink_window",
+            "move_window",
+            "select_window",
+            "select_pane",
+            "select_layout",
+            "resize_pane",
+            "set_title",
+            "send_keys",
+            "send_text",
+            "capture_pane",
+            "kill_pane",
+            "kill_window",
+            "kill_session",
+            "kill_server",
+            "clients",
+            "attach_argv",
+            "detach_client",
+            "set_option",
+            "get_option",
+            "unset_option",
+            "set_hook",
+            "show_hooks",
+            "set_environment",
+            "get_environment",
+            "unset_environment",
+            "set_buffer",
+            "show_buffer",
+            "delete_buffer",
+            "batch",
+            "operation",
+            "VERIFICATION-REPORT",
+            "policy,-status,-comparison",
+            "native_checked,-translation_exact,-native_filter,-reasons",
+            "server_id,-generation,-daemon_version,-capture_start,-capture_end",
+            "captured_ids,-local_ids,-native_ids",
+            "missing_ids,-unexpected_ids,-uncaptured_ids"
+          ]
+        },
+        "LibTmux::Session": {
+          "path": "lib/LibTmux/Session.pm",
+          "sha256": "937f4399513d814108380b75beb1c8824960593354f3955559439e2bc999da83",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "attached",
+            "created",
+            "id",
+            "name",
+            "path",
+            "window_links",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::SessionSelection": {
+          "path": "lib/LibTmux/SessionSelection.pm",
+          "sha256": "8ba23cdcf527ceb555ce392857c2b43b86b1b55ab4e881e5dc733ced99e95f4c",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION"
+          ]
+        },
+        "LibTmux::Snapshot": {
+          "path": "lib/LibTmux/Snapshot.pm",
+          "sha256": "d25f65b94405c1d9cb3ff3f0e268de567d79d4aca178efa66c14db8bd040df5d",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "from_records",
+            "server_id",
+            "generation",
+            "complete",
+            "metadata",
+            "sessions",
+            "windows",
+            "window_links",
+            "panes",
+            "clients",
+            "session_by_id",
+            "window_by_id",
+            "pane_by_id",
+            "to_records",
+            "EXECUTION"
+          ]
+        },
+        "LibTmux::Transport": {
+          "path": "lib/LibTmux/Transport.pm",
+          "sha256": "57dcb66db1c204f7fe6bcfee6623742dcfe425d8f9f0220e126d8e7c0a6535dc",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "run",
+            "start",
+            "RESULTS"
+          ]
+        },
+        "LibTmux::Window": {
+          "path": "lib/LibTmux/Window.pm",
+          "sha256": "df01e902cc513dee0e7458c2499078ca9141446066a822525a2e45864942e06e",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "active_pane",
+            "height",
+            "id",
+            "layout",
+            "links",
+            "name",
+            "panes",
+            "width",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::WindowLink": {
+          "path": "lib/LibTmux/WindowLink.pm",
+          "sha256": "30c8937a5806bb2996af3b21c3a6936a383a3e34ead6d591748a077b7b6adebf",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "active",
+            "id",
+            "index",
+            "session",
+            "window",
+            "OWNERSHIP"
+          ]
+        },
+        "LibTmux::WindowLinkSelection": {
+          "path": "lib/LibTmux/WindowLinkSelection.pm",
+          "sha256": "8301d518b97d620f76c7d1c7927c14809962a48b9ae5027768ea2163395550f1",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION"
+          ]
+        },
+        "LibTmux::WindowSelection": {
+          "path": "lib/LibTmux/WindowSelection.pm",
+          "sha256": "8b7956f6360344d3c3f8c7b1759f2e53e0acbbc98e81d2f3f864c339b8fcf8c2",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION"
+          ]
+        },
+        "LibTmux::X": {
+          "path": "lib/LibTmux/X.pm",
+          "sha256": "83438781e81322c06006dd84fe7bf357472a34c1e3e3a502babdc5b040036195",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION",
+            "METHODS",
+            "new",
+            "throw",
+            "message",
+            "path",
+            "entity",
+            "expected",
+            "received",
+            "matched_ids",
+            "count",
+            "result",
+            "dispatched",
+            "details",
+            "created",
+            "cause",
+            "CARDINALITY-AND-DATA-FAILURES",
+            "NoMatch",
+            "MultipleMatches",
+            "InvalidFilter",
+            "InvalidSelection",
+            "InvalidArgument",
+            "Unloaded",
+            "UnsupportedValue",
+            "Unsupported",
+            "AcquisitionRace",
+            "QueryMismatch",
+            "StaleReference",
+            "Spawn",
+            "NoServer",
+            "Command",
+            "Timeout",
+            "Cancelled",
+            "OutputLimit",
+            "Transport",
+            "Codec",
+            "NoSuchTarget",
+            "Creation",
+            "DIAGNOSTICS"
+          ]
+        }
+      },
+      "packages": {
+        "LibTmux": "LibTmux",
+        "LibTmux::Client": "LibTmux::Client",
+        "LibTmux::ClientSelection": "LibTmux::ClientSelection",
+        "LibTmux::Codec": "LibTmux::Codec",
+        "LibTmux::CommandResult": "LibTmux::CommandResult",
+        "LibTmux::Entity": "LibTmux::Entity",
+        "LibTmux::Filter": "LibTmux::Filter",
+        "LibTmux::Operation": "LibTmux::Operation",
+        "LibTmux::Pane": "LibTmux::Pane",
+        "LibTmux::PaneSelection": "LibTmux::PaneSelection",
+        "LibTmux::Platform::Linux": null,
+        "LibTmux::ProcessJob": "LibTmux::ProcessJob",
+        "LibTmux::QueryPlan": "LibTmux::QueryPlan",
+        "LibTmux::Schema": "LibTmux::Schema",
+        "LibTmux::Selection": "LibTmux::Selection",
+        "LibTmux::Selection::Iterator": "LibTmux::Selection::Iterator",
+        "LibTmux::Server": "LibTmux::Server",
+        "LibTmux::Session": "LibTmux::Session",
+        "LibTmux::SessionSelection": "LibTmux::SessionSelection",
+        "LibTmux::Snapshot": "LibTmux::Snapshot",
+        "LibTmux::Transport": "LibTmux::Transport",
+        "LibTmux::Window": "LibTmux::Window",
+        "LibTmux::WindowLink": "LibTmux::WindowLink",
+        "LibTmux::WindowLinkSelection": "LibTmux::WindowLinkSelection",
+        "LibTmux::WindowSelection": "LibTmux::WindowSelection",
+        "LibTmux::X": "LibTmux::X",
+        "LibTmux::X::AcquisitionRace": "LibTmux::X",
+        "LibTmux::X::Cancelled": "LibTmux::X",
+        "LibTmux::X::Codec": "LibTmux::X",
+        "LibTmux::X::Command": "LibTmux::X",
+        "LibTmux::X::Creation": "LibTmux::X",
+        "LibTmux::X::InvalidArgument": "LibTmux::X",
+        "LibTmux::X::InvalidFilter": "LibTmux::X",
+        "LibTmux::X::InvalidSelection": "LibTmux::X",
+        "LibTmux::X::MultipleMatches": "LibTmux::X",
+        "LibTmux::X::NoMatch": "LibTmux::X",
+        "LibTmux::X::NoServer": "LibTmux::X",
+        "LibTmux::X::NoSuchTarget": "LibTmux::X",
+        "LibTmux::X::OutputLimit": "LibTmux::X",
+        "LibTmux::X::QueryMismatch": "LibTmux::X",
+        "LibTmux::X::Spawn": "LibTmux::X",
+        "LibTmux::X::StaleReference": "LibTmux::X",
+        "LibTmux::X::Timeout": "LibTmux::X",
+        "LibTmux::X::Transport": "LibTmux::X",
+        "LibTmux::X::Unloaded": "LibTmux::X",
+        "LibTmux::X::Unsupported": "LibTmux::X",
+        "LibTmux::X::UnsupportedValue": "LibTmux::X"
+      }
+    },
+    "LibTmux-Async": {
+      "author": "TONY",
+      "release": "0.003",
+      "documents": {
+        "LibTmux::Async": {
+          "path": "lib/LibTmux/Async.pm",
+          "sha256": "a17ae3cb757850a86ec7b40ddc59902fa74df36241066b63b2d38f2f2f161d84",
+          "anchors": [
+            "NAME",
+            "DESCRIPTION",
+            "DOCUMENTATION"
+          ]
+        },
+        "LibTmux::Async::Server": {
+          "path": "lib/LibTmux/Async/Server.pm",
+          "sha256": "65af3416d55200c0d10d4a2a8982280254ee28b5d06b15222a1da7da6beeea11",
+          "anchors": [
+            "NAME",
+            "SYNOPSIS",
+            "METHODS",
+            "new",
+            "close",
+            "CORE-OPERATIONS",
+            "execute",
+            "cmd",
+            "new_session",
+            "new_window",
+            "split_pane",
+            "snapshot",
+            "listings",
+            "query_panes",
+            "explain_panes",
+            "rename_session",
+            "rename_window",
+            "link_window",
+            "unlink_window",
+            "move_window",
+            "select_window",
+            "select_pane",
+            "select_layout",
+            "resize_pane",
+            "set_title",
+            "send_keys",
+            "send_text",
+            "capture_pane",
+            "kill_pane",
+            "kill_window",
+            "kill_session",
+            "kill_server",
+            "clients",
+            "attach_argv",
+            "detach_client",
+            "set_option",
+            "get_option",
+            "unset_option",
+            "set_hook",
+            "show_hooks",
+            "set_environment",
+            "get_environment",
+            "unset_environment",
+            "set_buffer",
+            "show_buffer",
+            "delete_buffer",
+            "batch"
+          ]
+        },
+        "LibTmux::Async::Transport": {
+          "path": "lib/LibTmux/Async/Transport.pm",
+          "sha256": "67c30dd33016be2f7161aeaa4aab0ff3a153b06c8739a32fc9a8786642dc9375",
+          "anchors": [
+            "NAME",
+            "METHODS",
+            "new",
+            "execute",
+            "close"
+          ]
+        },
+        "LibTmux::Async::X": {
+          "path": "lib/LibTmux/Async/X.pm",
+          "sha256": "c1f342b52f45de5eee2c1970e806049a373f0f88d1c579ae4c157ed40756d272",
+          "anchors": [
+            "NAME",
+            "QueueFull",
+            "Closed"
+          ]
+        }
+      },
+      "packages": {
+        "LibTmux::Async": "LibTmux::Async",
+        "LibTmux::Async::Server": "LibTmux::Async::Server",
+        "LibTmux::Async::Transport": "LibTmux::Async::Transport",
+        "LibTmux::Async::X": "LibTmux::Async::X",
+        "LibTmux::Async::X::Closed": "LibTmux::Async::X",
+        "LibTmux::Async::X::QueueFull": "LibTmux::Async::X"
+      }
+    },
+    "LibTmux-Workspace": {
+      "author": "TONY",
+      "release": "0.003",
+      "documents": {
+        "LibTmux::Workspace": {
+          "path": "lib/LibTmux/Workspace.pm",
+          "sha256": "5201a40ede160f6f4931b475f753de3329280cc4c49469fab7242c7943f77aee",
+          "anchors": [
+            "NAME",
+            "SYNOPSIS",
+            "METHODS",
+            "new",
+            "from_json",
+            "plan",
+            "load",
+            "COMMAND-LINE",
+            "DOCUMENTATION"
+          ]
+        },
+        "LibTmux::Workspace::X": {
+          "path": "lib/LibTmux/Workspace/X.pm",
+          "sha256": "10c8aeefee1eff75d303559f1a30d4a71705ba638fa95e630fad0b4df04c0220",
+          "anchors": [
+            "NAME",
+            "EXCEPTIONS",
+            "Config",
+            "Conflict",
+            "Load",
+            "METHODS",
+            "report",
+            "report_data",
+            "cause"
+          ]
+        }
+      },
+      "packages": {
+        "LibTmux::Workspace": "LibTmux::Workspace",
+        "LibTmux::Workspace::X": "LibTmux::Workspace::X",
+        "LibTmux::Workspace::X::Config": "LibTmux::Workspace::X",
+        "LibTmux::Workspace::X::Conflict": "LibTmux::Workspace::X",
+        "LibTmux::Workspace::X::Load": "LibTmux::Workspace::X"
+      }
+    }
+  }
+}
diff --git a/site/src/data/port-guides/erlang.json b/site/src/data/port-guides/erlang.json
index 97ee54582..0ffc3e439 100644
--- a/site/src/data/port-guides/erlang.json
+++ b/site/src/data/port-guides/erlang.json
@@ -1,16 +1,16 @@
 {
   "source": {
     "repository": "libtmux/libtmux-erlang",
-    "revision": "f1a2e66c0fa15d1e8d4efa2725a159121815293b"
+    "revision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64"
   },
   "guides": [
     {
       "path": "README.md",
-      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Erlang\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux for Erlang\n\n</div>\n\nlibtmux for Erlang is a tmux client library. Create sessions, windows and panes,\ncapture their object graph, filter it as immutable data, and execute source\nqueries and owned operations explicitly.\n\n[Documentation](https://libtmux.org/en/erlang/latest/) ·\n[Core package](apps/libtmux_erlang/README.md) ·\n[Changelog](CHANGELOG.md)\n\n## Install\n\nUse Erlang/OTP **29.1.2**, Rebar3 **3.28.0**, Linux, tmux **3.3a–3.8**, and\n`make` with a C11 compiler. Native records are experimental in OTP 29. The core\nuses OTP libraries and a compiled external helper, with no NIF or third-party\nruntime packages.\n\nThis checkout is unreleased. Add its core application to your `rebar.config`:\n\n<!-- erlang-term -->\n\n```erlang\n{deps, [\n    {libtmux_erlang, {git_subdir,\n        \"https://github.com/libtmux/libtmux-erlang.git\",\n        {branch, \"master\"}, \"apps/libtmux_erlang\"}}\n]}.\n```\n\nCommit `rebar.lock` to keep the resolved commit. The\n[installation guide](docs/installation.md) covers application startup and\nbuilding a consumer. No Hex release is advertised.\n\n## Create, capture and query\n\nFrom this checkout, compile with the pinned tools:\n\n```console\n$ mise exec -- rebar3 compile\n```\n\nRun the complete program below on a private tmux server:\n\n```console\n$ mise exec -- escript tools/run_examples.escript readme\n```\n\nThe program starts an empty daemon on a unique private socket, verifies its\nassertions, and retires the owned server and clients. It leaves your existing\ntmux sessions alone. It uses only public core APIs and OTP runtime libraries;\nthe archive check also runs it outside this checkout.\nSave it as `readme_demo.erl` when reusing it in an application.\n\n<!-- example: examples/readme_demo.erl -->\n\n```erlang\n-module(readme_demo).\n-moduledoc \"Create a workspace, query its graph and preserve captured values.\".\n-export([run/1]).\n-import_record(tmux_model, [pane]).\n\n-spec run(binary()) -> map().\nrun(Executable) ->\n    Options = #{executable => Executable},\n    {ok, Result} = tmux_server:with_owned(Options, fun(Server) ->\n        {ok, Session} = tmux_session:create(Server, #{name => <<\"workspace\">>,\n            window_name => <<\"editor\">>, width => 120, height => 30,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Worker} = tmux_window:create(Session,\n            #{name => <<\"workers\">>,\n              launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Right} = tmux_pane:split(Worker, #{direction => horizontal,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, _} = tmux_window:select_layout(Worker, even_horizontal),\n        {ok, _} = tmux_pane:resize(Right, #{width => 40}),\n        {ok, Snapshot} = tmux_server:snapshot(Server),\n        Windows = tmux_select:windows(Snapshot),\n        Workers = #{name => <<\"workers\">>, panes => #{count => 2,\n            every => #{current_command => <<\"cat\">>}}},\n        {ok, Captured} = tmux_select:one(Workers, Windows),\n        {ok, Children} = tmux_snapshot:related(panes, Captured, Snapshot),\n        Ids = [Id || #pane{id = Id} <:- Children],\n        2 = length(Ids),\n        Criteria = #{width => #{gte => 20},\n            window => #{is => #{name => <<\"workers\">>}}},\n        Query = tmux_query:where(Criteria, tmux_query:panes(Server)),\n        {ok, Fetched} = tmux_query:fetch(Query),\n        2 = tmux_select:size(Fetched),\n        {ok, _} = tmux_window:rename(Worker, <<\"finished\">>),\n        <<\"workers\">> = tmux_model:get(name, Captured),\n        {ok, Fresh} = tmux_query:fetch(tmux_query:where(\n            #{name => <<\"finished\">>}, tmux_query:windows(Server))),\n        {ok, Renamed} = tmux_select:one(Fresh),\n        <<\"finished\">> = tmux_model:get(name, Renamed),\n        1 = length(tmux_snapshot:sessions(Snapshot)),\n        2 = length(tmux_snapshot:windows(Snapshot)),\n        3 = length(tmux_snapshot:panes(Snapshot)),\n        #{sessions => 1, windows => 2, panes => 3, matched_panes => 2,\n          captured_name => <<\"workers\">>, immutable => true}\n    end),\n    Result.\n```\n\nThe result includes this checked output. Captured rows keep their original\nvalues after a rename; actions and `fetch` perform explicit I/O.\n`tmux_server:with_owned/2` returns success after verified daemon cleanup. If cleanup fails,\nits error preserves the callback outcome and ownership token for recovery.\n\n<!-- example-output: readme_demo -->\n\n```json\n{\n  \"sessions\": 1,\n  \"windows\": 2,\n  \"panes\": 3,\n  \"matched_panes\": 2,\n  \"captured_name\": \"workers\",\n  \"immutable\": true\n}\n```\n\n## Follow the graph\n\nA window can have several links in one session and belong to more than one\nsession. Physical windows and panes remain unique; window links retain each\nsession/index membership.\n\n- [Linked windows and relationship queries](docs/graph.md): build two sessions,\n  link a shared window twice, and verify physical and membership counts.\n- [Daemon ownership](docs/ownership.md): choose private startup or a borrowed\n  socket, keep their lifetimes explicit and handle incomplete cleanup.\n- [Build command values](docs/commands.md): prepare a rename and resize, submit\n  them explicitly and inspect fresh state without changing captured rows.\n- [Control attachments](docs/control.md): verify connection identity, inspect\n  attachment effects and retire the client explicitly.\n- [Run a job and capture its result](docs/jobs.md): wait for a pane's completion\n  event, check its exit status, capture bytes, and cancel a separate operation.\n- [Local filters and source queries](docs/querying.md): Boolean criteria,\n  quantifiers, portable JSON, cardinality, coverage and execution plans.\n- [Fields and operators](docs/fields.md): generated from the runtime schema.\n- [Scoped options](docs/options.md): local ownership markers, explicit\n  inheritance and sparse arrays, with a source-pinned option catalogue.\n- [Buffers and paste](docs/buffers.md): preserve binary artifacts, inspect\n  names and control terminal delivery.\n- [Rearrange panes](docs/panes.md): isolate a running job in a window and join\n  it back, preserving its process and the original snapshot.\n- [Apply configuration and await a signal](docs/configuration.md): load settings\n  from stdin, observe the event and verify parse-only behavior.\n- [Pipe terminal output](docs/pipe.md): save a job's bytes, await its consumer\n  acknowledgement and verify the resulting log.\n- [Hooks and completion](docs/hooks.md): register a split callback, await its\n  acknowledgement and remove the local hook.\n- [Key tables](docs/keys.md): register application bindings, inspect native\n  listings and remove the owned table.\n- [Native commands](docs/commands-reference.md): source-derived parser metadata\n  and feature minimums, separate from library API and runtime qualification.\n- [API browser and source docs](docs/api.md): build searchable native reference\n  pages with specs, types and links to the exact source revision.\n\n## Decide whether it fits\n\nThe current path uses bounded one-shot tmux clients. Operations support\nnon-blocking submission, explicit waits, cancellation and ownership transfer.\nAn await timeout abandons that wait; it does not cancel the operation.\nCancellation after dispatch can leave the tmux outcome unknown.\n\nAn explicit control attachment verifies identity on its persistent connection\nand owns its client cleanup. Control command submission and output streams remain\nimplementation work. The\n[support and gaps](docs/compatibility.md) page lists\nwhat is exercised, what remains open, and the required Linux/tmux matrix.\nThere is no control-versus-streaming performance claim.\n\nThe [project policy](docs/project-policy.md) records the OTP application\nboundary and runtime dependencies.\n\n## Verify and contribute\n\n```console\n$ time python3 tools/check.py mid\n```\n\n```console\n$ time python3 tools/check.py outer\n```\n\nThe outer check owns its tmux fixtures and tests installed consumers. See\n[contributor setup](.github/CONTRIBUTING.md) for prerequisites and test budgets,\n[CI](https://github.com/libtmux/libtmux-erlang/actions/workflows/ci.yml) for\nindividual release/architecture results, and the [MIT license](LICENSE).\n\n[Branding assets](docs/branding.md) include the logo, icons, and social cards.\n"
+      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Erlang\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux for Erlang\n\n<p>\n  <a href=\"https://hex.pm/packages/libtmux_erlang\">Hex.pm</a> ·\n  <a href=\"https://libtmux.org/en/erlang/\">Documentation</a> ·\n  <a href=\"https://libtmux.org/en/erlang/latest/reference/\">API reference</a> ·\n  <a href=\"https://github.com/libtmux/libtmux-erlang/tree/master/examples\">Examples</a>\n</p>\n\n[![Erlang checks](https://github.com/libtmux/libtmux-erlang/actions/workflows/ci.yml/badge.svg)](https://github.com/libtmux/libtmux-erlang/actions/workflows/ci.yml)\n\n</div>\n\nlibtmux for Erlang is a tmux client library. Create\n[sessions](https://libtmux.org/en/erlang/latest/reference/tmux_session/),\n[windows](https://libtmux.org/en/erlang/latest/reference/tmux_window/) and\n[panes](https://libtmux.org/en/erlang/latest/reference/tmux_pane/), capture their\n[object graph](https://libtmux.org/en/erlang/latest/reference/tmux_snapshot/),\nfilter it as immutable data, and execute source queries and owned operations\nexplicitly.\n\n[Create, capture and query](#create-capture-and-query) ·\n[Core package](apps/libtmux_erlang/README.md) ·\n[Changelog](CHANGELOG.md)\n\n## Install\n\nUse Erlang/OTP **29.1.2**, Rebar3 **3.28.0**, Linux, tmux **3.3a–3.8**, and\n`make` with a C11 compiler. Native records are experimental in OTP 29. The core\nuses OTP libraries and a compiled external helper, with no NIF or third-party\nruntime packages.\n\nAdd the published core application from [Hex](https://hex.pm/packages/libtmux_erlang)\nto your `rebar.config`:\n\n<!-- erlang-term -->\n\n```erlang\n{deps, [{libtmux_erlang, \"0.0.1\"}]}.\n```\n\nThe API is still developing; pin an exact version and commit `rebar.lock`.\nThe\n[installation guide](docs/installation.md) covers application startup and\nbuilding a consumer from Hex or a source checkout.\n\n## Create, capture and query\n\n### [`tmux_server:with_owned/2`][api-with-owned]: create a private tmux graph\n\nFrom this checkout, compile with the pinned tools:\n\n```console\n$ mise exec -- rebar3 compile\n```\n\nRun the complete program below on a private tmux server:\n\n```console\n$ mise exec -- escript tools/run_examples.escript readme\n```\n\nThe program starts an empty daemon on a unique private socket, verifies its\nassertions, and retires the owned server and clients. It leaves your existing\ntmux sessions alone. It uses only public core APIs and OTP runtime libraries;\nthe archive check also runs it outside this checkout.\nSave it as `readme_demo.erl` when reusing it in an application.\n\n[`tmux_server`](https://libtmux.org/en/erlang/latest/reference/tmux_server/)\nowns the connection and scoped server lifetime.\n[`tmux_snapshot`](https://libtmux.org/en/erlang/latest/reference/tmux_snapshot/)\nholds captured rows;\n[`tmux_select`](https://libtmux.org/en/erlang/latest/reference/tmux_select/)\nfilters those rows locally. A\n[`tmux_query`](https://libtmux.org/en/erlang/latest/reference/tmux_query/)\nexecutes a new observation when fetched.\n\n<!-- example: examples/readme_demo.erl -->\n\n```erlang\n-module(readme_demo).\n-moduledoc \"Create a workspace, query its graph and preserve captured values.\".\n-export([run/1]).\n-import_record(tmux_model, [pane]).\n\n-spec run(binary()) -> map().\nrun(Executable) ->\n    Options = #{executable => Executable},\n    {ok, Result} = tmux_server:with_owned(Options, fun(Server) ->\n        {ok, Session} = tmux_session:create(Server, #{name => <<\"workspace\">>,\n            window_name => <<\"editor\">>, width => 120, height => 30,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Worker} = tmux_window:create(Session,\n            #{name => <<\"workers\">>,\n              launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, Right} = tmux_pane:split(Worker, #{direction => horizontal,\n            launch => #{argv => [<<\"/bin/cat\">>]}}),\n        {ok, _} = tmux_window:select_layout(Worker, even_horizontal),\n        {ok, _} = tmux_pane:resize(Right, #{width => 40}),\n        {ok, Snapshot} = tmux_server:snapshot(Server),\n        Windows = tmux_select:windows(Snapshot),\n        Workers = #{name => <<\"workers\">>, panes => #{count => 2,\n            every => #{current_command => <<\"cat\">>}}},\n        {ok, Captured} = tmux_select:one(Workers, Windows),\n        {ok, Children} = tmux_snapshot:related(panes, Captured, Snapshot),\n        Ids = [Id || #pane{id = Id} <:- Children],\n        2 = length(Ids),\n        Criteria = #{width => #{gte => 20},\n            window => #{is => #{name => <<\"workers\">>}}},\n        Query = tmux_query:where(Criteria, tmux_query:panes(Server)),\n        {ok, Fetched} = tmux_query:fetch(Query),\n        2 = tmux_select:size(Fetched),\n        {ok, _} = tmux_window:rename(Worker, <<\"finished\">>),\n        <<\"workers\">> = tmux_model:get(name, Captured),\n        {ok, Fresh} = tmux_query:fetch(tmux_query:where(\n            #{name => <<\"finished\">>}, tmux_query:windows(Server))),\n        {ok, Renamed} = tmux_select:one(Fresh),\n        <<\"finished\">> = tmux_model:get(name, Renamed),\n        1 = length(tmux_snapshot:sessions(Snapshot)),\n        2 = length(tmux_snapshot:windows(Snapshot)),\n        3 = length(tmux_snapshot:panes(Snapshot)),\n        #{sessions => 1, windows => 2, panes => 3, matched_panes => 2,\n          captured_name => <<\"workers\">>, immutable => true}\n    end),\n    Result.\n```\n\nThe result includes this checked output. Captured rows keep their original\nvalues after a rename; actions and `fetch` perform explicit I/O.\n`tmux_server:with_owned/2` returns success after verified daemon cleanup. If cleanup fails,\nits error preserves the callback outcome and ownership token for recovery.\n\n<!-- example-output: readme_demo -->\n\n```json\n{\n  \"sessions\": 1,\n  \"windows\": 2,\n  \"panes\": 3,\n  \"matched_panes\": 2,\n  \"captured_name\": \"workers\",\n  \"immutable\": true\n}\n```\n\n## Follow the graph\n\n### [`tmux_snapshot:related/3`][api-related]: follow shared windows\n\nA window can have several links in one session and belong to more than one\nsession. Physical windows and panes remain unique; window links retain each\nsession/index membership.\n\n- [Linked windows and relationship queries](docs/graph.md): build two sessions,\n  link a shared window twice, and verify physical and membership counts.\n\n### [`tmux_select:where/2`][api-where]: filter captured rows\n\n- [Local filters and source queries](docs/querying.md): Boolean criteria,\n  quantifiers, portable JSON, cardinality, coverage and execution plans.\n- [Fields and operators](docs/fields.md): generated from the runtime schema.\n\n### [`tmux_query:fetch/1`][api-fetch]: observe tmux explicitly\n\nThe [querying guide](docs/querying.md) follows a source query through planning,\nexecution and a new immutable selection. Local filtering preserves its\ncaptured values; fetching performs I/O.\n\n### [`tmux_server:with_server/2`][api-with-server]: borrow an existing server\n\n- [Daemon ownership](docs/ownership.md): choose private startup or a borrowed\n  socket, keep their lifetimes explicit and handle incomplete cleanup.\n- [Control attachments](docs/control.md): verify connection identity, inspect\n  attachment effects and retire the client explicitly.\n\n### [`tmux_operation:await/2`][api-await]: wait for submitted work\n\n- [Run a job and capture its result](docs/jobs.md): wait for a pane's completion\n  event, check its exit status, capture bytes, and cancel a separate operation.\n- [Build command values](docs/commands.md): prepare a rename and resize, submit\n  them explicitly and inspect fresh state without changing captured rows.\n\n## More examples\n\n- [Scoped options](docs/options.md): local ownership markers, explicit\n  inheritance and sparse arrays, with a source-pinned option catalogue.\n- [Buffers and paste](docs/buffers.md): preserve binary artifacts, inspect\n  names and control terminal delivery.\n- [Rearrange panes](docs/panes.md): isolate a running job in a window and join\n  it back, preserving its process and the original snapshot.\n- [Apply configuration and await a signal](docs/configuration.md): load settings\n  from stdin, observe the event and verify parse-only behavior.\n- [Pipe terminal output](docs/pipe.md): save a job's bytes, await its consumer\n  acknowledgement and verify the resulting log.\n- [Hooks and completion](docs/hooks.md): register a split callback, await its\n  acknowledgement and remove the local hook.\n- [Key tables](docs/keys.md): register application bindings, inspect native\n  listings and remove the owned table.\n- [Native commands](docs/commands-reference.md): source-derived parser metadata\n  and feature minimums, separate from library API and runtime qualification.\n- [API browser and source docs](docs/api.md): build searchable native reference\n  pages with specs, types and links to the exact source revision.\n\n## Decide whether it fits\n\nThe current path uses bounded one-shot tmux clients. Operations support\nnon-blocking submission, explicit waits, cancellation and ownership transfer.\nAn await timeout abandons that wait; it does not cancel the operation.\nCancellation after dispatch can leave the tmux outcome unknown.\n\nAn explicit control attachment verifies identity on its persistent connection\nand owns its client cleanup. Control command submission and output streams remain\nimplementation work. The\n[support and gaps](docs/compatibility.md) page lists\nwhat is exercised, what remains open, and the required Linux/tmux matrix.\nThere is no control-versus-streaming performance claim.\n\nThe [project policy](docs/project-policy.md) records the OTP application\nboundary and runtime dependencies.\n\n## Verify and contribute\n\n```console\n$ time python3 tools/check.py mid\n```\n\n```console\n$ time python3 tools/check.py outer\n```\n\nThe outer check owns its tmux fixtures and tests installed consumers. See\n[contributor setup](.github/CONTRIBUTING.md) for prerequisites and test budgets,\n[CI](https://github.com/libtmux/libtmux-erlang/actions/workflows/ci.yml) for\nindividual release/architecture results, and the [MIT license](LICENSE).\nMaintainers can follow the [Hex release instructions](.github/RELEASE.md).\n\n[Branding assets](docs/branding.md) include the logo, icons, and social cards.\n\n[api-with-owned]: https://libtmux.org/en/erlang/latest/reference/tmux_server-with_owned-2/\n[api-related]: https://libtmux.org/en/erlang/latest/reference/tmux_snapshot-related-3/\n[api-where]: https://libtmux.org/en/erlang/latest/reference/tmux_select-where-2/\n[api-fetch]: https://libtmux.org/en/erlang/latest/reference/tmux_query-fetch-1/\n[api-with-server]: https://libtmux.org/en/erlang/latest/reference/tmux_server-with_server-2/\n[api-await]: https://libtmux.org/en/erlang/latest/reference/tmux_operation-await-2/\n"
     },
     {
       "path": "docs/installation.md",
-      "content": "# Install the core application\n\nThe core OTP application is `libtmux_erlang`. It lives in an umbrella, so a\nRebar3 source dependency must use `git_subdir` with `apps/libtmux_erlang`.\nUsing the repository root as an ordinary single-app Git dependency does not\nselect the core application.\n\nThe [README](../README.md#install) contains the dependency declaration tested\nin an isolated Rebar3 consumer. Rebar3 resolves the branch to a commit in\n`rebar.lock`; commit that file. To choose a reviewed commit directly, use\nRebar3's `{ref, Commit}` form instead of `{branch, \"master\"}`.\n\nAdd `libtmux_erlang` to your application's `applications` list in its\n`.app.src`. For an interactive consumer, compile and start the Rebar3 shell:\n\n```console\n$ rebar3 compile\n```\n\n```console\n$ rebar3 shell\n```\n\n## Inspect an existing server\n\n`open/1` borrows an existing daemon. It does not start tmux or create a session.\nFrom a shell attached to the server you intend to inspect, obtain its socket:\n\n```console\n$ export LIBTMUX_SOCKET=\"$(tmux display-message -p '#{socket_path}')\"\n```\n\nSave this module as `src/inspect_demo.erl` in the consumer application:\n\n<!-- example: examples/inspect_demo.erl -->\n\n```erlang\n-module(inspect_demo).\n-moduledoc \"Inspect an existing tmux socket without changing its sessions.\".\n-export([run/2]).\n\n-spec run(binary(), binary()) -> map().\nrun(Socket, Executable) ->\n    {ok, _} = application:ensure_all_started(libtmux_erlang),\n    Endpoint = #{socket_path => Socket, executable => Executable},\n    {ok, Result} = tmux_server:with_server(Endpoint, fun(Server) ->\n        {ok, Snapshot} = tmux_server:snapshot(Server),\n        #{sessions => length(tmux_snapshot:sessions(Snapshot)),\n          windows => length(tmux_snapshot:windows(Snapshot)),\n          panes => length(tmux_snapshot:panes(Snapshot))}\n    end),\n    Result.\n```\n\nRun it through the consumer's Rebar shell. The executable path comes from PATH;\nthe socket must be the absolute path selected above:\n\n```console\n$ rebar3 shell \\\n    --eval '\n        Socket = list_to_binary(os:getenv(\"LIBTMUX_SOCKET\")),\n        Tmux = list_to_binary(os:find_executable(\"tmux\")),\n        io:format(\"~p~n\", [inspect_demo:run(Socket, Tmux)]),\n        halt().'\n```\n\nThe returned map counts physical objects in one captured view. Closing the\nlibrary handle preserves the borrowed daemon and its sessions. This module\nalso runs against the installed archive in the outer check. The private-server\n[README program](../README.md#create-capture-and-query) adds creation, native\nrecord patterns, graph traversal and a fresh query.\n\nDirect native-record construction needs `tmux_model` loaded first; its\nconstructors load normally and validate observations. Do not distribute record\nheaders or serialize record internals as a wire format.\n\n## Requirements\n\n| Component | Current requirement |\n| --- | --- |\n| Erlang/OTP | Exactly the qualified latest-stable baseline, 29.1.2 |\n| Build tool | Rebar3 3.28.0 |\n| tmux | 3.3a–3.8, including intermediate releases; CI tests both endpoints |\n| Runtime platform | Linux x86_64 and arm64 qualification cells |\n| Native build | C11 compiler, libc headers and make |\n| Core dependencies | OTP kernel, stdlib and crypto; no JSON package or NIF |\n| Checkout example runner | Python 3.12+ for owned-server readiness observation |\n\nThe helper builds from its packaged C source. Installation must fail if that\nbuild fails; there is no runtime executable download. The helper's original\nlicense is retained separately from the project's MIT license.\n\nThere is no published Hex package or release artifact for this checkout.\n[API docs](api.md) describe the local browser build. [Compatibility](compatibility.md)\nseparates current checks from the remaining suite and delivery gates.\n"
+      "content": "# Install the core application\n\nThe core OTP application is\n[`libtmux_erlang`](https://hex.pm/packages/libtmux_erlang) on Hex.\n\nThe [README](../README.md#install) contains the dependency declaration tested\nin an isolated Rebar3 consumer. Pin an exact version while the API develops\nand commit `rebar.lock` to retain the resolved package checksum.\n\nAdd `libtmux_erlang` to your application's `applications` list in its\n`.app.src`. For an interactive consumer, compile and start the Rebar3 shell:\n\n```console\n$ rebar3 compile\n```\n\n```console\n$ rebar3 shell\n```\n\n## Install a source checkout\n\nThe repository is an umbrella. For development from source, use `git_subdir`\nto select `apps/libtmux_erlang`:\n\n<!-- erlang-term -->\n\n```erlang\n{deps, [\n    {libtmux_erlang, {git_subdir,\n        \"https://github.com/libtmux/libtmux-erlang.git\",\n        {branch, \"master\"}, \"apps/libtmux_erlang\"}}\n]}.\n```\n\nRebar3 records the branch's resolved commit in `rebar.lock`. To select a\nreviewed commit directly, use `{ref, Commit}` instead of `{branch, \"master\"}`.\n\n## Inspect an existing server\n\n`open/1` borrows an existing daemon. It does not start tmux or create a session.\nFrom a shell attached to the server you intend to inspect, obtain its socket:\n\n```console\n$ export LIBTMUX_SOCKET=\"$(tmux display-message -p '#{socket_path}')\"\n```\n\nSave this module as `src/inspect_demo.erl` in the consumer application:\n\n<!-- example: examples/inspect_demo.erl -->\n\n```erlang\n-module(inspect_demo).\n-moduledoc \"Inspect an existing tmux socket without changing its sessions.\".\n-export([run/2]).\n\n-spec run(binary(), binary()) -> map().\nrun(Socket, Executable) ->\n    {ok, _} = application:ensure_all_started(libtmux_erlang),\n    Endpoint = #{socket_path => Socket, executable => Executable},\n    {ok, Result} = tmux_server:with_server(Endpoint, fun(Server) ->\n        {ok, Snapshot} = tmux_server:snapshot(Server),\n        #{sessions => length(tmux_snapshot:sessions(Snapshot)),\n          windows => length(tmux_snapshot:windows(Snapshot)),\n          panes => length(tmux_snapshot:panes(Snapshot))}\n    end),\n    Result.\n```\n\nRun it through the consumer's Rebar shell. The executable path comes from PATH;\nthe socket must be the absolute path selected above:\n\n```console\n$ rebar3 shell \\\n    --eval '\n        Socket = list_to_binary(os:getenv(\"LIBTMUX_SOCKET\")),\n        Tmux = list_to_binary(os:find_executable(\"tmux\")),\n        io:format(\"~p~n\", [inspect_demo:run(Socket, Tmux)]),\n        halt().'\n```\n\nThe returned map counts physical objects in one captured view. Closing the\nlibrary handle preserves the borrowed daemon and its sessions. This module\nalso runs against the installed archive in the outer check. The private-server\n[README program](../README.md#create-capture-and-query) adds creation, native\nrecord patterns, graph traversal and a fresh query.\n\nDirect native-record construction needs `tmux_model` loaded first; its\nconstructors load normally and validate observations. Do not distribute record\nheaders or serialize record internals as a wire format.\n\n## Requirements\n\n| Component | Current requirement |\n| --- | --- |\n| Erlang/OTP | Exactly the qualified latest-stable baseline, 29.1.2 |\n| Build tool | Rebar3 3.28.0 |\n| tmux | 3.3a–3.8, including intermediate releases; CI tests both endpoints |\n| Runtime platform | Linux x86_64 and arm64 qualification cells |\n| Native build | C11 compiler, libc headers and make |\n| Core dependencies | OTP kernel, stdlib and crypto; no JSON package or NIF |\n| Checkout example runner | Python 3.12+ for owned-server readiness observation |\n\nThe helper builds from its packaged C source. Installation must fail if that\nbuild fails; there is no runtime executable download. The helper's original\nlicense is retained separately from the project's MIT license.\n\nHex serves the core package; HexDocs is not published. The hosted\n[API reference](https://libtmux.org/en/erlang/latest/reference/) lives on the\n[shared documentation site](https://libtmux.org/en/erlang/), and\n[API docs](api.md) describe the local browser build.\n[Compatibility](compatibility.md) separates current checks from the remaining\nsuite and delivery gates.\n"
     },
     {
       "path": "docs/graph.md",
@@ -74,7 +74,7 @@
     },
     {
       "path": "docs/compatibility.md",
-      "content": "# Support and remaining gaps\n\nSupport covers tmux **3.3a–3.8**, including intermediate releases, on Linux\nx86_64 and arm64. The [workflow](../.github/workflows/ci.yml) tests the oldest\nsupported and newest stable tmux releases on both architectures.\nOTP 29.1.2 is the only supported Erlang baseline;\nolder-OTP compatibility branches are not maintained. Native records remain an\nexperimental language dependency in OTP 29. Do not persist their internals or\nassume compatibility with another OTP line.\n\n| Platform | tmux releases in the required matrix |\n| --- | --- |\n| Ubuntu 24.04 x86_64 | 3.3a, 3.8 |\n| Ubuntu 24.04 arm64 | 3.3a, 3.8 |\n\nCI uses only the latest stable Erlang/OTP release. Testing the endpoints keeps\nthe routine matrix small; it does not exclude releases between them from\nsupport. Earlier intermediate-version results retain their recorded scope.\n\nInspect the individual jobs at the commit you will consume. A minimum-version\ncheck does not prove runtime support on every newer release. Tracking builds,\nmacOS, native Windows and psmux are not advertised as qualified platforms.\n\nLinux must provide readable `/proc/self/task/<pid>/children`, enabled by\nCONFIG_PROC_CHILDREN. The helper checks this interface before launching a\nchild. An unavailable interface returns `unsupported_capability` with\n`capability => proc_children`, the OS `errno` and `outcome => not_started`.\nSee the [helper protocol](../apps/libtmux_erlang/c_src/README.md) for cleanup\nevidence and the limits of native process ownership.\n\n## Retained rows and upgrades\n\nNative model version 2 adds a private captured target association to each\nobserved row. Actions check the entity, stable ID, origin and snapshot ID;\npane associations also retain the observed window and index, and window-link\nassociations retain their session, index and expected physical window.\nActions reject edited target fields before dispatch. Valid-shaped binding\nmismatches return `observation_mismatch`; detached and malformed rows retain\ntheir validation errors. `tmux_server:bind/2` reads the requested target and returns\na new actionable row. Ordinary record matching and detached constructors\nremain available.\n\nThe private value retains identifiers, not the snapshot graph. It prevents\naccidental retargeting through public row updates; it is not an authorization\nboundary against trusted code running inside the VM. The internal construction\nfunctions remain implementation details.\n\nDiscard version-1 rows and snapshots when upgrading to model version 2. Stop\nconsumers that retain them, clear their process/ETS state and freshly observe\nthe server after restart. This release supplies no `appup`/`relup` conversion.\nOld or unknown model versions fail row validation. New code must validate a\nretained value before accessing fields added by another model version.\n\nEvery exported-field addition, rename, removal or default change requires a\nmodel compatibility review independently of the OTP version. Its changelog\nmust state whether retained values remain usable, need an explicit validated\nconversion, or must be discarded. Do not assume hot loading changes fields in\nexisting native values.\n\n`tmux_model:to_map/1` extracts the documented domain fields from a valid row.\nValidate those fields with the destination model's constructor when migrating\ndata. The map loses actionable provenance; bind it through a freshly\nconstructed row before an action. It is not a versioned storage or cross-port\nwire format: absence atoms, binary bytes and field inventories still require\nan application-defined schema.\n\n## Implemented surfaces\n\n| Surface | Current behavior |\n| --- | --- |\n| Model | Exported native session/window/window-link/pane records; runtime validation |\n| Capture | Immutable complete graph, coverage, ordering, conflict detection and read intervals |\n| Local query | Map predicates, Boolean callbacks, quantifiers, cardinality and bounded JSON |\n| Source query | Explicit plans/fetch, conservative candidates, full residuals and final limits |\n| Operations | Bounded one-shot submission, waits, cancellation, transfer and cleanup |\n| Control attachment | Explicit session, same-connection identity, no-output/ignore-size, skipped environment update and separate native cleanup |\n| Daemon ownership | Empty private startup, separate ownership token, caller lifetime, explicit stop and identity-checked namespace cleanup |\n| Domain commands | Initial create/read/rename/kill calls, explicit client/session selection, checked window memberships, pane split/break/join/move/swap/resize, pane/window respawn, window layouts, literal/key input and capture |\n| Options | Explicit local/global tables, local or inherited reads, indexed writes/unsets and generated source metadata; hooks remain outside the option API |\n| Hooks | Versioned builtin arrays, indexed command values, inheritance and explicit execution contexts |\n| Buffers | Named or automatic binary load, exact show, metadata lists, delete/rename and paste; native version differences are explicit |\n| Server utilities | Command values for literal source-file/stdin configuration and native wait-for signals, waits and explicit advisory locks |\n| Pane pipe | Literal shell command, output/input/both directions, native toggle and explicit stop; tmux-owned process and delivery checks |\n\nThe [examples](../examples) exercise the current public API. Real integration\nchecks use private sockets and verify owned process retirement. A captured row\ncan disappear before an action; stable IDs are not permission to reinterpret a\nmissing target positionally.\n\n## Not yet shipped\n\nControl command submission and groups and output subscriptions/streams remain\nimplementation work. Complete performance qualification remains open.\n\nTyped command coverage, generated capability inventory, registry delivery,\npublic cross-port filter conformance, published native API pages, shared-site documentation and\nindependent implementation reviews remain open. Current test success does not\npass those unfinished surfaces. No registry or documentation publication is\nclaimed.\n\n## Source installation\n\nThe [source-package check](../tools/check_source_package.py) builds the core\napplication with pinned `rebar3_hex` tooling. It serves the exact tarball\nthrough a signed local registry, then creates a fresh Rebar3 consumer whose\nonly dependency is the core. The core must compile its helper from packaged C\nsource. Missing compiler support fails installation.\nThe installed examples, native-record imports, model-upgrade check and owned\ntransport checks run against that consumer.\n\nCI runs this gate on both supported architectures with tmux 3.3a and 3.8.\nInspect its receipt for the commit being consumed. These local source artifacts\nretain the development version; the check neither publishes to Hex nor proves\nan independently retrieved registry release. The older compiled-archive check\nremains separate evidence for its own payload.\n\n## Performance evidence\n\nThe current suite checks behavior and resource limits. It does not establish a\ncontrol/grouping/streaming comparison because those execution lanes are not implemented.\nAny published benchmark must compare equal workloads and values, state the\nsource/tool/platform identities, and report errors and cleanup as well as time.\nTest-loop durations are not throughput benchmarks.\n"
+      "content": "# Support and remaining gaps\n\nSupport covers tmux **3.3a–3.8**, including intermediate releases, on Linux\nx86_64 and arm64. The [workflow](../.github/workflows/ci.yml) tests the oldest\nsupported and newest stable tmux releases on both architectures.\nOTP 29.1.2 is the only supported Erlang baseline;\nolder-OTP compatibility branches are not maintained. Native records remain an\nexperimental language dependency in OTP 29. Do not persist their internals or\nassume compatibility with another OTP line.\n\n| Platform | tmux releases in the required matrix |\n| --- | --- |\n| Ubuntu 24.04 x86_64 | 3.3a, 3.8 |\n| Ubuntu 24.04 arm64 | 3.3a, 3.8 |\n\nCI uses only the latest stable Erlang/OTP release. Testing the endpoints keeps\nthe routine matrix small; it does not exclude releases between them from\nsupport. Earlier intermediate-version results retain their recorded scope.\n\nInspect the individual jobs at the commit you will consume. A minimum-version\ncheck does not prove runtime support on every newer release. Tracking builds,\nmacOS, native Windows and psmux are not advertised as qualified platforms.\n\nLinux must provide readable `/proc/self/task/<pid>/children`, enabled by\nCONFIG_PROC_CHILDREN. The helper checks this interface before launching a\nchild. An unavailable interface returns `unsupported_capability` with\n`capability => proc_children`, the OS `errno` and `outcome => not_started`.\nSee the [helper protocol](../apps/libtmux_erlang/c_src/README.md) for cleanup\nevidence and the limits of native process ownership.\n\n## Retained rows and upgrades\n\nNative model version 2 adds a private captured target association to each\nobserved row. Actions check the entity, stable ID, origin and snapshot ID;\npane associations also retain the observed window and index, and window-link\nassociations retain their session, index and expected physical window.\nActions reject edited target fields before dispatch. Valid-shaped binding\nmismatches return `observation_mismatch`; detached and malformed rows retain\ntheir validation errors. `tmux_server:bind/2` reads the requested target and returns\na new actionable row. Ordinary record matching and detached constructors\nremain available.\n\nThe private value retains identifiers, not the snapshot graph. It prevents\naccidental retargeting through public row updates; it is not an authorization\nboundary against trusted code running inside the VM. The internal construction\nfunctions remain implementation details.\n\nDiscard version-1 rows and snapshots when upgrading to model version 2. Stop\nconsumers that retain them, clear their process/ETS state and freshly observe\nthe server after restart. This release supplies no `appup`/`relup` conversion.\nOld or unknown model versions fail row validation. New code must validate a\nretained value before accessing fields added by another model version.\n\nEvery exported-field addition, rename, removal or default change requires a\nmodel compatibility review independently of the OTP version. Its changelog\nmust state whether retained values remain usable, need an explicit validated\nconversion, or must be discarded. Do not assume hot loading changes fields in\nexisting native values.\n\n`tmux_model:to_map/1` extracts the documented domain fields from a valid row.\nValidate those fields with the destination model's constructor when migrating\ndata. The map loses actionable provenance; bind it through a freshly\nconstructed row before an action. It is not a versioned storage or cross-port\nwire format: absence atoms, binary bytes and field inventories still require\nan application-defined schema.\n\n## Implemented surfaces\n\n| Surface | Current behavior |\n| --- | --- |\n| Model | Exported native session/window/window-link/pane records; runtime validation |\n| Capture | Immutable complete graph, coverage, ordering, conflict detection and read intervals |\n| Local query | Map predicates, Boolean callbacks, quantifiers, cardinality and bounded JSON |\n| Source query | Explicit plans/fetch, conservative candidates, full residuals and final limits |\n| Operations | Bounded one-shot submission, waits, cancellation, transfer and cleanup |\n| Control attachment | Explicit session, same-connection identity, no-output/ignore-size, skipped environment update and separate native cleanup |\n| Daemon ownership | Empty private startup, separate ownership token, caller lifetime, explicit stop and identity-checked namespace cleanup |\n| Domain commands | Initial create/read/rename/kill calls, explicit client/session selection, checked window memberships, pane split/break/join/move/swap/resize, pane/window respawn, window layouts, literal/key input and capture |\n| Options | Explicit local/global tables, local or inherited reads, indexed writes/unsets and generated source metadata; hooks remain outside the option API |\n| Hooks | Versioned builtin arrays, indexed command values, inheritance and explicit execution contexts |\n| Buffers | Named or automatic binary load, exact show, metadata lists, delete/rename and paste; native version differences are explicit |\n| Server utilities | Command values for literal source-file/stdin configuration and native wait-for signals, waits and explicit advisory locks |\n| Pane pipe | Literal shell command, output/input/both directions, native toggle and explicit stop; tmux-owned process and delivery checks |\n\nThe [examples](../examples) exercise the current public API. Real integration\nchecks use private sockets and verify owned process retirement. A captured row\ncan disappear before an action; stable IDs are not permission to reinterpret a\nmissing target positionally.\n\n## Not yet shipped\n\nControl command submission and groups and output subscriptions/streams remain\nimplementation work. Complete performance qualification remains open.\n\nTyped command coverage, generated capability inventory, public cross-port\nfilter conformance, published native API pages, shared-site documentation and\nindependent implementation reviews remain open. Current test success does not\npass those unfinished surfaces. The only registry publication is the core\npackage on [Hex](https://hex.pm/packages/libtmux_erlang); HexDocs is not\npublished.\n\n## Source installation\n\nThe [source-package check](../tools/check_source_package.py) builds the core\napplication with pinned `rebar3_hex` tooling. It serves the exact tarball\nthrough a signed local registry, then creates a fresh Rebar3 consumer whose\nonly dependency is the core. The core must compile its helper from packaged C\nsource. Missing compiler support fails installation.\nThe installed examples, native-record imports, model-upgrade check and owned\ntransport checks run against that consumer.\n\nCI runs this gate on both supported architectures with tmux 3.3a and 3.8.\nInspect its receipt for the commit being consumed. These local source artifacts\nretain the development version; the check neither publishes to Hex nor proves\nan independently retrieved registry release. The older compiled-archive check\nremains separate evidence for its own payload.\n\n## Performance evidence\n\nThe current suite checks behavior and resource limits. It does not establish a\ncontrol/grouping/streaming comparison because those execution lanes are not implemented.\nAny published benchmark must compare equal workloads and values, state the\nsource/tool/platform identities, and report errors and cleanup as well as time.\nTest-loop durations are not throughput benchmarks.\n"
     },
     {
       "path": "docs/pipe.md",
diff --git a/site/src/data/port-guides/perl.json b/site/src/data/port-guides/perl.json
index 3a9d31f42..7ad21520b 100644
--- a/site/src/data/port-guides/perl.json
+++ b/site/src/data/port-guides/perl.json
@@ -1,32 +1,32 @@
 {
   "source": {
     "repository": "libtmux/libtmux-perl",
-    "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa"
+    "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69"
   },
   "guides": [
     {
       "path": "README.md",
-      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Perl\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux for Perl\n\n</div>\n\nControl tmux with explicit commands, captured graphs, and ordinary Perl arrays.\nTargets stable Perl 5.44.0 and Linux x86_64 LP64, including WSL. These development\ndistributions are not published on CPAN.\n\n[Documentation](https://libtmux.org/en/perl/latest/) ·\n[API reference](https://libtmux.org/en/perl/latest/reference/) ·\n[Run the examples](examples/README.md)\n\n```perl\nuse v5.44;\nuse LibTmux::Server;\n\nmy $server = LibTmux::Server->new(socket_name => 'example');\nmy $snapshot = $server->snapshot;  # Explicit I/O; server must already exist.\nmy $active = $snapshot->panes\n    ->where({ active => true, width => { -gte => 80 } })\n    ->grep(sub ($pane) { $pane->current_command eq 'sleep' });\n\nfor my $pane ($active->@*) {\n    say $pane->id, ' ', $pane->window->name;\n}\n```\n\n| Distribution | Location | Runtime dependencies |\n| --- | --- | --- |\n| [`LibTmux`](packages/core/README.md) | [packages/core](packages/core) | Perl standard library. |\n| [`LibTmux-Async`](packages/async/README.md) | [packages/async](packages/async) | Versioned core, Future, IO::Async, IO::Async::Loop::Ppoll and IO::Ppoll; caller-owned Ppoll loop. |\n| [`LibTmux-Workspace`](packages/workspace/README.md) | [packages/workspace](packages/workspace) | Versioned core; packaged JSON loader CLI. |\n\nStart with [installation](docs/installation.md),\n[basic orchestration](docs/orchestration.md), and\n[filtering](docs/filtering.md). Read [graph identity](docs/graph.md) before\nworking with linked windows, [query planning](docs/query-planning.md) for\nexplicit native filters, [errors and recovery](docs/errors.md),\n[async execution](docs/async.md), and [workspace loading](docs/workspace.md).\nThe [architecture decisions](docs/dev/adr/index.md) explain these contracts,\ntheir alternatives, and the upstream source models behind them.\nInstalled API documentation uses native POD; for example `perldoc\nLibTmux::Server` and `perldoc LibTmux::Selection`.\n\n[Complete examples](examples/README.md) run against uniquely owned tmux sockets and\nassert results and cleanup. [Compatibility](docs/compatibility.md) records\nsupport for tmux 3.3a–3.8 and CI coverage of the range endpoints. Captured\nselections perform no tmux I/O; their methods preserve order and duplicates\nand return one fixed type in every calling context. Native array access\nremains available.\n\nMCP is excluded. Persistent control mode, streaming APIs, tmux command lists,\nserialized regexes, and relation pushdown are deferred.\n\nSee [contributing](.github/CONTRIBUTING.md) for exact checks and tool setup,\n[Perl choices](.github/PERL.md) for source-backed decisions, and\n[branding assets](docs/branding.md) for logos and social cards.\n"
+      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Perl\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux for Perl\n\n</div>\n\nlibtmux for Perl is a tmux client library for creating sessions, arranging\nwindows, sending input, and querying captured state with ordinary Perl arrays.\nCore and workspace use the Perl standard library at runtime; the optional\nasync distribution adds Futures and a caller-owned event loop.\n\n[Quick start](#server-new_session-create-a-session-and-arrange-its-windows) ·\n[Filter panes](#selection-where-filter-with-criteria-and-perl-callbacks) ·\n[Packages](#choose-a-package) ·\n[Documentation](https://libtmux.org/en/perl/) ·\n[Guides](https://libtmux.org/en/perl/latest/guides/) ·\n[API reference](https://libtmux.org/en/perl/latest/reference/) ·\n[CPAN](https://metacpan.org/dist/LibTmux)\n\n## [`Server->new_session`][server-new-session]: create a session and arrange its windows\n\nUse Perl 5.44 and tmux 3.3a–3.8 on Linux x86_64 LP64, including WSL. With\nPerl and cpm on `PATH`, install the published core distribution from CPAN:\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux\n```\n\nRun the [complete program](packages/core/examples/quickstart.pl) with an explicit\nsocket path. It creates a session, splits its editor window, adds a logs\nwindow, and retains a snapshot. It removes only the session it created,\nincluding on failure; it preserves any other sessions on the selected server.\nSave the program below as `quickstart.pl`, or run the linked file from a checkout:\n\n```console\n$ perl quickstart.pl \"${TMPDIR:-/tmp}/libtmux-perl-$$.sock\"\n```\n\n<!-- example: packages/core/examples/quickstart.pl -->\n```perl\nuse v5.44;\nuse LibTmux::Server;\n\nmy $socket = shift @ARGV // die \"Usage: $0 SOCKET_PATH [TMUX]\\n\";\nmy $server = LibTmux::Server->new(\n    socket_path => $socket,\n    executable  => shift(@ARGV) // 'tmux',\n    config_file => '/dev/null',\n);\nmy ($session, $snapshot, $failure);\ntry {\n    $session = $server->new_session(\n        name    => 'perl-quickstart',\n        command => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    my $editor = $session->window_links->one->window;\n    $server->rename_window(window => $editor, name => 'editor');\n    $server->split_pane(\n        pane       => $editor->panes->one,\n        horizontal => true,\n        command    => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    $server->new_window(\n        session => $session,\n        name    => 'logs',\n        command => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    $snapshot = $server->snapshot;\n}\ncatch ($error) {\n    $failure = $error;\n    $session //= $error->created if $error isa LibTmux::X::Creation;\n}\nif ($session) {\n    try { $server->kill_session(session => $session) }\n    catch ($cleanup) {\n        warn \"session cleanup failed: $cleanup\\n\";\n        $failure //= $cleanup;\n    }\n}\ndie $failure if defined $failure;\n\n# The captured graph remains readable after its live session has gone.\nfor my $link ($snapshot->session_by_id($session->id)->window_links->@*) {\n    my $count = $link->window->panes->count;\n    say $link->window->name, ': ', $count, $count == 1 ? ' pane' : ' panes';\n}\n```\n\nThe captured graph remains readable after the live session is removed:\n\n```text\neditor: 2 panes\nlogs: 1 pane\n```\n\n[`Server`](https://libtmux.org/en/perl/latest/reference/libtmux-server/) owns\nexplicit commands. Its\n[`new_session`](https://libtmux.org/en/perl/latest/reference/libtmux-server-new_session/)\nstarts tmux when the selected socket has no server. Construction alone does no\nI/O. The example uses an empty tmux configuration and literal Perl command\narrays; it needs no editor, shell wrapper, Python, or repository fixture.\nAn existing session with the example's name is a conflict, not a cleanup target.\n\n## [`Selection->where`][selection-where]: filter with criteria and Perl callbacks\n\nContinue with the retained `$snapshot` above. A\n[`Selection`](https://libtmux.org/en/perl/latest/reference/libtmux-selection/)\nis a blessed array reference: declarative `where`, one-argument `grep`, and\nordinary `map` work together without another tmux call.\n\n<!-- example: packages/core/examples/workflow.pl#filter -->\n```perl\nmy $snapshot = $server->snapshot;\nmy $panes =\n    $snapshot->windows->one({name => 'editor'})\n    ->panes->where({width => {-gte => 1}})\n    ->grep(sub ($pane) { $pane->height > 0 });\nmy @ids    = map { $_->id } $panes->@*;\nmy $active = $panes->one({active => true});\nsay 'editor panes: ',          scalar @ids;\nsay 'active pane belongs to ', $active->window->name;\n\n```\n\n`one` throws on zero or multiple occurrences. `one_or_undef` represents absence\nand still rejects ambiguity. `to_array` makes a fresh unblessed arrayref.\nNative array access stays mutable; library methods validate all members.\nThe [filtering guide](docs/filtering.md) covers nulls, numeric comparisons,\nsame-child quantifiers, and invalid-filter diagnostics.\n\n## [`Server->send_text`][server-send-text]: send text, capture output, and set environment\n\nThe [live workflow](packages/core/examples/workflow.pl) performs this section\nwhile its session is still open:\n\n<!-- example: packages/core/examples/workflow.pl#input -->\n```perl\n$server->send_text(\n    pane  => $right,\n    text  => 'hello from Perl',\n    enter => true\n);\nmy $screen = $server->capture_pane(pane => $right, start => -100);\nsay 'captured bytes: ', length $screen;\n$server->set_environment(\n    session => $session,\n    name    => 'PROJECT',\n    value   => 'api',\n);\nsay 'PROJECT=',\n    $server->get_environment(session => $session, name => 'PROJECT');\n\n```\n\n[`send_text`](https://libtmux.org/en/perl/latest/reference/libtmux-server-send_text/)\nsends literal text; `send_keys` accepts tmux key names.\n[`capture_pane`](https://libtmux.org/en/perl/latest/reference/libtmux-server-capture_pane/)\nreturns current screen/history bytes. Command acceptance does not prove that a\npane application finished its work. Use an application-specific observable\ncompletion condition when that matters. See [orchestration](docs/orchestration.md).\n\n## [`LibTmux::Filter`][filter]: save a reusable filter\n\n[`Filter`](https://libtmux.org/en/perl/latest/reference/libtmux-filter/) compiles\ncriteria once and owns its normalized data. In the same workflow:\n\n<!-- example: packages/core/examples/workflow.pl#wire -->\n```perl\nmy $filter = LibTmux::Filter->new(\n    entity => 'pane',\n    where  => {active => true, width => {-gte => 1}},\n);\nmy $restored = LibTmux::Filter->from_json($filter->to_json);\nmy $selected = $panes->where($restored);\nsay 'restored filter matches: ', $selected->count;\n\n```\n\nThe `libtmux.where/v1` wire format preserves schema-selected text, numbers,\nbooleans, and nulls. Native `qr//` remains available in callbacks; serialized\nregex dialects are deferred. [Query plans](docs/query-planning.md) explain\nwhich scalar predicates can be verified by tmux.\n\n## Choose a package\n\n| Distribution | Use it for | Package and API |\n| --- | --- | --- |\n| [LibTmux](packages/core/README.md) | Commands, snapshots, graph navigation, filtering, options and environment. Perl standard library at runtime. | [CPAN](https://metacpan.org/dist/LibTmux) · [API](https://libtmux.org/en/perl/latest/reference/) · [POD](https://metacpan.org/pod/LibTmux) |\n| [LibTmux-Async](packages/async/README.md) | Concurrent Future-returning operations and explicit executor cleanup. Adds Future, IO::Async, IO::Async::Loop::Ppoll and IO::Ppoll. | [CPAN](https://metacpan.org/dist/LibTmux-Async) · [API](https://libtmux.org/en/perl/latest/reference/libtmux-async-server/) · [POD](https://metacpan.org/pod/LibTmux::Async) |\n| [LibTmux-Workspace](packages/workspace/README.md) | Validate, plan, and load JSON workspaces with a library or CLI. Uses core and the Perl standard library. | [CPAN](https://metacpan.org/dist/LibTmux-Workspace) · [API](https://libtmux.org/en/perl/latest/workspace/reference/libtmux-workspace/) · [POD](https://metacpan.org/pod/LibTmux::Workspace) |\n\nEach package has its own README, license, metadata, and runnable consumer\nexamples. Async closes its executor without destroying a borrowed tmux server.\nWorkspace uses public synchronous core APIs and does not require async.\nInstall either companion by module name; its declared core dependency is\ninstalled automatically:\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux::Async\n```\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux::Workspace\n```\n\nThe `0.x` API can change between releases. Read each distribution's `Changes`\nfile before upgrading and pin versions in applications that need a fixed API.\n\n## Run the examples and read the guides\n\n[The examples index](examples/README.md) separates standalone installed-package\nprograms from repository qualification demos. The runner checks output,\ncleanup, and preservation of borrowed sessions:\n\n```console\n$ mise exec -- make examples\n```\n\nRead [installation](docs/installation.md), [orchestration](docs/orchestration.md),\n[filtering](docs/filtering.md), [graph identity](docs/graph.md),\n[query planning](docs/query-planning.md), [async execution](docs/async.md),\n[workspace loading](docs/workspace.md), and [errors and recovery](docs/errors.md).\nInstalled API documentation uses POD: `perldoc LibTmux::Server`.\n\n[Compatibility](docs/compatibility.md) covers tmux 3.3a–3.8 inclusive; CI tests\nonly Perl 5.44 and the two tmux endpoints. Persistent control,\nstreaming subscriptions, tmux command chaining, serialized regexes, and relation\npushdown are deferred. [Architecture decisions](docs/dev/adr/index.md) explain\nthe contracts and costs.\n\n[Contributing](.github/CONTRIBUTING.md) covers author setup and checks.\n[Perl choices](.github/PERL.md) records dependency decisions;\n[branding](docs/branding.md) describes the logos and social cards.\n\n[server-new-session]: https://libtmux.org/en/perl/latest/reference/libtmux-server-new_session/\n[selection-where]: https://libtmux.org/en/perl/latest/reference/libtmux-selection-where/\n[server-send-text]: https://libtmux.org/en/perl/latest/reference/libtmux-server-send_text/\n[filter]: https://libtmux.org/en/perl/latest/reference/libtmux-filter/\n"
     },
     {
       "path": "docs/installation.md",
-      "content": "---\ntitle: Install from source\ndescription: Install from source with the Perl libtmux distributions.\n---\n\nThese distributions are unpublished. Use Perl 5.44.0 and install core before\nworkspace or optional async. Use the repository's pinned cpm author setup,\nor an existing cpm installation. From the repository root:\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/core\n```\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/workspace\n```\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/async\n```\n\nCore and workspace need only the Perl standard library at runtime. Async adds\nFuture, IO::Async, IO::Async::Loop::Ppoll and IO::Ppoll. Its caller supplies a\nPpoll loop; IO::Ppoll includes an XS extension. See the\n[async guide](async.md) for construction and cleanup.\nConfigure/test/develop requirements remain separate.\nTo inspect installed documentation:\n\n```console\n$ perldoc LibTmux::Server\n```\n\nThe [contributor guide](../.github/CONTRIBUTING.md) documents pinned local\nprovisioning, archive builds, and isolated installed-consumer verification.\nNo PAUSE upload, tag, or release is implied by source installation.\n"
+      "content": "---\ntitle: Install Perl packages\ndescription: Install the independent Perl core, async, and workspace distributions.\n---\n\nUse Perl 5.44 and tmux 3.3a–3.8 on Linux x86_64 LP64, including WSL. Install\nthe packages you need from CPAN, or use a source checkout for development.\nThe [documentation homepage](https://libtmux.org/en/perl/) links the guides\nand [API reference](https://libtmux.org/en/perl/latest/reference/).\n\n## Install from CPAN\n\nInstall [Perl](https://www.perl.org/get.html) and\n[cpm](https://github.com/skaji/cpm#installation), then keep the same interpreter\nand installation prefix for all selected packages.\n\nInstall [LibTmux](https://metacpan.org/dist/LibTmux) for commands, snapshots,\nand filtering:\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux\n```\n\nAdd [LibTmux-Workspace](https://metacpan.org/dist/LibTmux-Workspace) for the\nJSON library and packaged `libtmux-workspace` CLI:\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux::Workspace\n```\n\nAdd [LibTmux-Async](https://metacpan.org/dist/LibTmux-Async) for Future-returning\noperations:\n\n```console\n$ cpm install \\\n    --global \\\n    LibTmux::Async\n```\n\nThe companions declare their core dependency; the installer resolves it\nautomatically. Core and workspace use the Perl standard library at runtime.\nAsync adds Future, IO::Async, IO::Async::Loop::Ppoll, and IO::Ppoll; the latter\nincludes an XS extension and requires a C compiler. Configure and test\ndependencies are declared separately and resolved by the installer. Consumer\nprograms do not require the repository's author tools or Python. Other loop\nbackends and Linux ABIs are unsupported.\n\nThe `0.x` API can change between releases. Consult each distribution's\n`Changes` file before upgrading and pin versions in applications that need a\nfixed API.\n\n## Prepare a source checkout\n\nInstall [Perl](https://www.perl.org/get.html) and\n[cpm](https://github.com/skaji/cpm#installation). With mise installed, this\ncheckout's `.tool-versions` selects Perl 5.44.0. Clone the repository:\n\n```console\n$ git clone https://github.com/libtmux/libtmux-perl.git\n```\n\n```console\n$ cd libtmux-perl\n```\n\nIf the pinned interpreter is not installed:\n\n```console\n$ mise install\n```\n\nCheck the interpreter selected for installation and execution:\n\n```console\n$ mise exec -- perl -v\n```\n\nThe [contributor setup](../.github/CONTRIBUTING.md#environment) supplies a\nhash-verified standalone cpm installer and an isolated author environment.\nConsumer programs do not require those author tools or Python. Keep the same\nPerl interpreter and installation prefix for all selected distributions.\n\n## Install from the source checkout\n\nWith Perl 5.44 and cpm on `PATH`, install core from the repository root:\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/core\n```\n\nAdd workspace for the JSON library and packaged `libtmux-workspace` command:\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/workspace\n```\n\nAdd async for Future-returning operations:\n\n```console\n$ cpm install \\\n    --global \\\n    ./packages/async\n```\n\n## Run a first program\n\nThe [core quick start](../packages/core/examples/quickstart.pl) creates its own\nsession, splits a pane, adds a window, captures the graph, and removes that\nsession. It starts tmux if the explicit socket is unused:\n\n```console\n$ perl packages/core/examples/quickstart.pl \"${TMPDIR:-/tmp}/libtmux-perl-$$.sock\"\n```\n\n```text\neditor: 2 panes\nlogs: 1 pane\n```\n\nAll package examples import installed public modules. No source-tree\n`PERL5LIB`, repository fixture, Python, or syscall boilerplate is required.\nUse [the examples index](../examples/README.md) to choose filtering, concurrent\noperations, workspace loading, or the author qualification programs.\n\nInstalled API documentation uses POD:\n\n```console\n$ perldoc LibTmux::Server\n```\n\nFor a missing executable, install tmux or pass its path as the example's second\nargument. `NoServer` on `snapshot` means the selected socket has no daemon;\ncreate a session with `new_session` first. A conflicting example session name\nis an error and never grants permission to delete that existing session.\n"
     },
     {
       "path": "docs/filtering.md",
-      "content": "---\ntitle: Filter captured selections\ndescription: Native Perl arrays, strict criteria, graph quantifiers, and wire filters.\n---\n\nUse `where({...})` for query data and `grep(sub ($pane) {...})` for arbitrary\nPerl behavior. Native `->@*`, indexing, `grep`, `map`, `sort`, and List::Util\nremain available. `to_array` returns a fresh unblessed array reference.\n\nFields select comparison semantics: text, safe decimal integers, booleans,\nnullability, allowed operators, and relation cardinality come from one catalog.\nFalse, zero, \"0\", empty text, and undef remain distinct. Integer operands are\nbounded to +/-9007199254740991; invalid numeric text never becomes zero.\n\n| Grammar | Meaning |\n| --- | --- |\n| scalar or `-eq`, `-ne` | Schema-directed equality and complement. |\n| `-in`, `-not_in` arrays | Explicit membership; empty arrays mean false/true. |\n| `-lt`, `-lte`, `-gt`, `-gte` | Authorized numeric ordering. |\n| `-contains`, `-starts_with`, `-ends_with` | Literal, case-sensitive text. |\n| `-and`, `-or` arrays; `-not` node | Complete criteria nodes. |\n| `-some`, `-every`, `-none` | To-many quantifiers over the complete captured domain. |\n| `-is`, `-is_not` | To-one criteria or explicit nullable absence. |\n\nFields/operators in a hash are conjoined. Duplicate Perl hash keys overwrite;\nuse multiple operators or explicit `-and`. Empty criteria and empty AND are\ntrue; empty OR is false. On a loaded empty relation, some is false and\nevery/none true. Conditions inside one some apply to the same child; separate\nexistentials may match different children. Unloaded relations never prove empty.\n\nFull compilation precedes evaluation, even on empty selections. Hash keys\ntraverse lexically; logical arrays preserve their order. Short-circuiting may\navoid unavailable reads once a result is known. Known-null ordering/text is\nfalse; negation reverses known results, never missing-data failures.\n\nEvaluation order affects failures as well as matches. For an inactive record\nwith unloaded width, an AND array testing `active` before `width` can return\nfalse; reversing those nodes reads width first and throws. Flattening them into\na hash instead selects lexical order. Wire serialization retains logical-array\norder; optimizers must preserve availability and error behavior. The depth-64\nand 10,000-node compilation limits do not cap membership operands or string bytes.\n\nNative arrays remain mutable. Every library method validates all N occurrences\nbefore returning even `first`, `count` or `exists`; that validation is O(N).\nPredicates may then stop early. `where` evaluates and validates its output;\n`iterator` also copies membership. Raw indexing and dereferencing retain normal\nPerl behavior. A mutable selection cannot safely cache a prior validation.\n\n`LibTmux::Filter` owns normalized criteria, supports plain records and explicit\nregistered readers, and exports JSON with schema `\"libtmux.where/v1\"`.\nWire names use camelCase and dash-free operators. Regex/coderefs/cycles/blessed\nvalues are refused at that data boundary. Native Perl `qr//` remains available\nin callbacks.\n\nThe complete example below is copied from an executed program. The fixture\nhelper uses an owned socket, observes process exit, and cleans up on failures.\n\n<!-- example: selection.pl -->\n```perl\nuse v5.44;\nuse FindBin;\nuse lib \"$FindBin::Bin/../scripts/lib\";\nuse LibTmuxFixture;\nuse LibTmux::Filter;\nuse List::Util qw(any first);\nLibTmuxFixture->run(\n    sub ($server, $root) {\n        my $session = $server->new_session(\n            name    => 'example',\n            command => ['/bin/sleep', '120']\n        );\n        my $initial = $session->window_links->one->window->panes->one;\n        $server->split_pane(\n            pane       => $initial,\n            horizontal => true,\n            command    => ['/bin/sleep', '120']\n        );\n        my $snapshot = $server->snapshot;\n        my $panes    = $snapshot->panes->where({current_command => 'sleep'})\n            ->grep(sub ($pane) { $pane->width >= 1 });\n        die 'expected two panes' unless $panes->count == 2;\n        for my $pane ($panes->@*) {\n            say $pane->id . ' ' . $pane->current_command;\n        }\n        my $only_active = $panes->one({active => true});\n        die 'active pane unavailable' unless defined $only_active;\n        my $has_active   = any { $_->active } $panes->@*;\n        my $first_active = first { $_->active } $panes->@*;\n        die 'List::Util alternatives differ'\n            unless $has_active && $first_active->id eq $only_active->id;\n        my @ids      = map  { $_->id } $panes->@*;\n        my @positive = grep { $_->width > 0 } $panes->@*;\n        die 'ordinary Perl arrays differ' unless @ids == 2 && @positive == 2;\n        my $filter =\n            LibTmux::Filter->new(entity => 'pane', where => {active => true});\n        my $decoded = LibTmux::Filter->from_json($filter->to_json);\n        die 'wire filter changed meaning'\n            unless $panes->where($decoded)->one->id eq $only_active->id;\n        my $retained = do {\n            my $observed = $server->snapshot;\n            $observed->pane_by_id($only_active->id);\n        };\n        die 'retained graph lost a relationship'\n            unless $retained->window->panes->count == 2;\n        my $same_child = $snapshot->windows->where(\n            {panes => {-some => {-and => [{index => 0}, {index => 1}]}}});\n        my $different_children = $snapshot->windows->where(\n            {\n                -and => [\n                    {panes => {-some => {index => 0}}},\n                    {panes => {-some => {index => 1}}}\n                ]\n            }\n        );\n        die 'quantifiers conflated children'\n            unless $same_child->count == 0 && $different_children->count == 1;\n        my $where = {active => true, width => {-gte => 1}};\n        my $local = $server->query_panes(where => $where, pushdown => 'never');\n        my $verification;\n        my $native = $server->query_panes(\n            where           => $where,\n            pushdown        => 'require',\n            on_verification => sub ($report) { $verification = $report },\n        );\n        die 'native verification was not observed'\n            unless $verification->{status} eq 'agreed'\n            && $verification->{comparison} eq 'exact_ids';\n        die 'native/local disagreement'\n            unless join(',', map { $_->id } @$local) eq\n            join(',', map { $_->id } @$native);\n        say 'selection, wire, graph lifetime, quantifiers, and query: ok';\n    }\n);\n```\n\n## Independent-port subset\n\nThe shared fixture vocabulary is proposed for this port. A source-pinned Python\nQueryList evaluator agrees on the advertised subset: Boolean/integer/text\nequality, literal contains/prefix/suffix, membership, and empty membership.\nThe adaptation maps wire field names to record keys and operators to native\nQueryList lookup keywords. It does not claim that Python accepts this wire API.\n\nKnown-null equality initially disagreed: the pinned Python filter rejects None\nfields before its equality lookup. That difference remains recorded. Numeric\nordering, availability errors, graph quantifiers, validation on empty data,\nand canonical-name enforcement have no equivalent declared Python contract\nand are marked unsupported, not passed. Perl fixtures cover those semantics.\nSee [the fixtures](../conformance/where-v1.json) and\n[the independent source pin](../scripts/conformance-reference.json).\n"
+      "content": "---\ntitle: Filter captured selections\ndescription: Native Perl arrays, strict criteria, graph quantifiers, and wire filters.\n---\n\nUse `where({...})` for query data and `grep(sub ($pane) {...})` for arbitrary\nPerl behavior. Native `->@*`, indexing, `grep`, `map`, `sort`, and List::Util\nremain available. `to_array` returns a fresh unblessed array reference.\n\nFields select comparison semantics: text, safe decimal integers, booleans,\nnullability, allowed operators, and relation cardinality come from one catalog.\nFalse, zero, \"0\", empty text, and undef remain distinct. Integer operands are\nbounded to +/-9007199254740991; invalid numeric text never becomes zero.\n\n| Grammar | Meaning |\n| --- | --- |\n| scalar or `-eq`, `-ne` | Schema-directed equality and complement. |\n| `-in`, `-not_in` arrays | Explicit membership; empty arrays mean false/true. |\n| `-lt`, `-lte`, `-gt`, `-gte` | Authorized numeric ordering. |\n| `-contains`, `-starts_with`, `-ends_with` | Literal, case-sensitive text. |\n| `-and`, `-or` arrays; `-not` node | Complete criteria nodes. |\n| `-some`, `-every`, `-none` | To-many quantifiers over the complete captured domain. |\n| `-is`, `-is_not` | To-one criteria or explicit nullable absence. |\n\nFields/operators in a hash are conjoined. Duplicate Perl hash keys overwrite;\nuse multiple operators or explicit `-and`. Empty criteria and empty AND are\ntrue; empty OR is false. On a loaded empty relation, some is false and\nevery/none true. Conditions inside one some apply to the same child; separate\nexistentials may match different children. Unloaded relations never prove empty.\n\nFull compilation precedes evaluation, even on empty selections. Hash keys\ntraverse lexically; logical arrays preserve their order. Short-circuiting may\navoid unavailable reads once a result is known. Known-null ordering/text is\nfalse; negation reverses known results, never missing-data failures.\n\nEvaluation order affects failures as well as matches. For an inactive record\nwith unloaded width, an AND array testing `active` before `width` can return\nfalse; reversing those nodes reads width first and throws. Flattening them into\na hash instead selects lexical order. Wire serialization retains logical-array\norder; optimizers must preserve availability and error behavior. The depth-64\nand 10,000-node compilation limits do not cap membership operands or string bytes.\n\nNative arrays remain mutable. Every library method validates all N occurrences\nbefore returning even `first`, `count` or `exists`; that validation is O(N).\nPredicates may then stop early. `where` evaluates and validates its output;\n`iterator` also copies membership. Raw indexing and dereferencing retain normal\nPerl behavior. A mutable selection cannot safely cache a prior validation.\n\n`LibTmux::Filter` owns normalized criteria, supports plain records and explicit\nregistered readers, and exports JSON with schema `\"libtmux.where/v1\"`.\nWire names use camelCase and dash-free operators. Regex/coderefs/cycles/blessed\nvalues are refused at that data boundary. Native Perl `qr//` remains available\nin callbacks.\n\n## Query installed objects and ordinary records\n\nThe [live workflow](../packages/core/examples/workflow.pl) creates two editor\npanes before running these local queries:\n\n<!-- example: packages/core/examples/workflow.pl#filter -->\n```perl\nmy $snapshot = $server->snapshot;\nmy $panes =\n    $snapshot->windows->one({name => 'editor'})\n    ->panes->where({width => {-gte => 1}})\n    ->grep(sub ($pane) { $pane->height > 0 });\nmy @ids    = map { $_->id } $panes->@*;\nmy $active = $panes->one({active => true});\nsay 'editor panes: ',          scalar @ids;\nsay 'active pane belongs to ', $active->window->name;\n\n```\n\nThe [record-only program](../packages/core/examples/filters.pl) runs with the\ninstalled core and no tmux server:\n\n```console\n$ perl packages/core/examples/filters.pl\n```\n\n<!-- example: packages/core/examples/filters.pl#records -->\n```perl\nmy $filter = LibTmux::Filter->new(\n    entity => 'pane',\n    where  => {\n        active          => true,\n        current_command => {-in  => [qw(perl vim)]},\n        width           => {-gte => 80},\n    },\n);\nmy @records = (\n    {id => '%1', active => true,  current_command => 'perl', width => 120},\n    {id => '%2', active => false, current_command => 'perl', width => 120},\n    {id => '%3', active => true,  current_command => 'vim',  width => 40},\n);\nmy @matches = grep { $filter->matches($_) } @records;\nsay 'matching records: ', join ', ', map { $_->{id} } @matches;\n\n```\n\nIt prints `matching records: %1`. Its complete source also checks a JSON\nround trip. No author fixture, Python evaluator, or object framework is needed\nby either consumer program.\n\n## Save criteria for reuse\n\nIn the live workflow, the compiled filter can be stored as versioned JSON and\nreused on a captured selection:\n\n<!-- example: packages/core/examples/workflow.pl#wire -->\n```perl\nmy $filter = LibTmux::Filter->new(\n    entity => 'pane',\n    where  => {active => true, width => {-gte => 1}},\n);\nmy $restored = LibTmux::Filter->from_json($filter->to_json);\nmy $selected = $panes->where($restored);\nsay 'restored filter matches: ', $selected->count;\n\n```\n\nChanging the original criteria hash does not change a compiled filter. Schema\nvalidation still applies after decoding; executable callbacks belong in `grep`,\nnot in the wire data.\n\n## Distinguish one child from two children\n\nOne `-some` subtree applies every condition to the same child. Two existential\nsubtrees can match different children. The workflow limits the domain to its\nown editor window and checks both cases:\n\n<!-- example: packages/core/examples/workflow.pl#relations -->\n```perl\nmy $windows    = $snapshot->windows->where({id => $editor->id});\nmy $same_child = $windows->where(\n    {\n        panes => {-some => {-and => [{index => 0}, {index => 1}]}},\n    }\n);\nmy $different_children = $windows->where(\n    {\n        -and => [\n            {panes => {-some => {index => 0}}},\n            {panes => {-some => {index => 1}}},\n        ],\n    }\n);\nsay 'same child: ',         $same_child->count;\nsay 'different children: ', $different_children->count;\n\n```\n\nAn individual pane cannot have both index 0 and index 1, so `same child` is 0.\nThe window has both panes, so `different children` is 1. Loaded empty relations\nmake `-some` false and `-every`/`-none` true. Unloaded relations remain errors\nwhen evaluation needs them. See [graph identity](graph.md).\n\n## Independent-port subset\n\nThe shared fixture vocabulary is proposed for this port. A source-pinned Python\nQueryList evaluator agrees on the advertised subset: Boolean/integer/text\nequality, literal contains/prefix/suffix, membership, and empty membership.\nThe adaptation maps wire field names to record keys and operators to native\nQueryList lookup keywords. It does not claim that Python accepts this wire API.\n\nKnown-null equality initially disagreed: the pinned Python filter rejects None\nfields before its equality lookup. That difference remains recorded. Numeric\nordering, availability errors, graph quantifiers, validation on empty data,\nand canonical-name enforcement have no equivalent declared Python contract\nand are marked unsupported, not passed. Perl fixtures cover those semantics.\nSee [the fixtures](../conformance/where-v1.json) and\n[the independent source pin](../scripts/conformance-reference.json).\n"
     },
     {
       "path": "examples/README.md",
-      "content": "# Examples\n\nRun these programs from a provisioned checkout of [libtmux for Perl](../README.md).\nThey use Perl 5.44.0, Linux x86_64 LP64, and tmux 3.3a–3.8. The async programs\nalso use the dependencies in the [author setup](../.github/CONTRIBUTING.md#environment).\n`Future::AsyncAwait` is needed only for `await.pl`.\n\n## Run the examples\n\n```console\n$ mise exec -- make examples\n```\n\nThe [runner](../scripts/run-examples.pl) rejects unsuccessful programs and\nmissing expected output. The installed-artifact CI job runs these same\nprograms against an isolated installation prefix. The two tmux CI cells run\nthem against the oldest supported and newest stable releases.\n\n| Program | What it demonstrates | Expected result |\n| --- | --- | --- |\n| [quickstart.pl](quickstart.pl) | Create a session, rename and split a window, add a window, and traverse a snapshot. | Two windows named `editor` and `logs`; the selected pane belongs to `editor`. |\n| [selection.pl](selection.pl) | `where`, `grep`, native arrays, cardinality, compiled filters, relations, retained graphs, and native query verification. | `selection, wire, graph lifetime, quantifiers, and query: ok` |\n| [workspace.pl](workspace.pl) | Plan and load a JSON workspace, then repeat it with `existing => 'skip'`. | `workspace load and repeat: ok` |\n| [async.pl](async.pl) | Capture through a caller-owned Ppoll loop and wait for executor cleanup. | `async capture and cleanup: ok` |\n| [await.pl](await.pl) | Use optional caller-side `async`/`await` syntax with the same core result objects. | `optional caller await syntax: ok` |\n| [async-lifecycle.pl](async-lifecycle.pl) | Preserve operation failures, handle cancellation, and observe cleanup without destroying a borrowed server. | Capture, failure, and cancellation scenarios all report completed executor cleanup. |\n\n## Server ownership\n\nThe checkout demos use the repository's fixture to create a unique socket,\nignore user tmux configuration, and verify owned process exit during cleanup.\nThe fixture is author tooling, not an installed package API. The runner supplies\nlibrary paths and the child-reaping scope needed by these programs.\n\nAfter installing core and async, `async-lifecycle.pl` also works as a standalone\nconsumer program. It takes an explicit socket path for an existing server and\ncloses only its executor:\n\n```console\n$ perl examples/async-lifecycle.pl --help\n```\n\nRead the [async guide](../docs/async.md) before using its failure or cancellation\noptions. Cancellation does not prove cleanup has finished; keep driving the\nloop until `close` completes successfully.\n\n## Quote tested source\n\nThe complete programs embedded in the reader guides use `example` markers.\n[The snippet check](../scripts/check-snippets.pl) compares each marked block\nwith its source file:\n\n```console\n$ mise exec -- make check-snippets\n```\n\nKeep the program, its expected output in the runner, and its documentation\nconsistent. State fixture or existing-server prerequisites next to an excerpt.\nOffer a capability only after its example runs and checks the claimed result;\nthe [shared showcase standard](https://github.com/libtmux/docs/issues/243)\ndescribes the evidence required by libtmux.org.\n"
+      "content": "# Examples\n\nStart with the standalone programs in each native distribution. They use\ninstalled public modules and ordinary Perl; no Python, author fixture, or\nsource-tree library path is required. The baseline is Perl 5.44 and Linux\nx86_64 LP64 with tmux 3.3a–3.8.\n\n## Run an installed-package example\n\n[Install core](../docs/installation.md), then run the quick start from a\ncheckout with an explicit socket path:\n\n```console\n$ perl packages/core/examples/quickstart.pl \"${TMPDIR:-/tmp}/libtmux-perl-$$.sock\"\n```\n\nThe example starts tmux if necessary, creates and removes its own session,\nand preserves other sessions on that socket. Each live program accepts an\noptional second argument naming the tmux executable. A conflicting example\nsession name is an error; existing sessions are never cleanup targets.\n\n| Program | Task | Expected result |\n| --- | --- | --- |\n| [Core quick start](../packages/core/examples/quickstart.pl) | Create, split, rename, capture, clean up, and retain the graph. | `editor: 2 panes` and `logs: 1 pane`. |\n| [Core workflow](../packages/core/examples/workflow.pl) | Arrange windows, send text, capture output, set environment, filter, compare quantifiers, and verify native queries. | `core workflow: ok`. |\n| [Filter records](../packages/core/examples/filters.pl) | Match ordinary hash records, round-trip JSON, and inspect typed validation errors without tmux. | `%1` matches; the invalid numeric operand reports its criterion path. |\n| [Async operations](../packages/async/examples/concurrent.pl) | Run concurrent Futures and ordered batches, remove the created session, and await close. | `first` before `second`; `async operations and cleanup: ok`. |\n| [Workspace loading](../packages/workspace/examples/load.pl) | Read the adjacent JSON, plan, load, inspect two windows and three panes, repeat with skip, and clean up. | `workspace plan, load, repeat: ok`. |\n\nAsync requires the separate distribution and its Ppoll dependencies. Workspace\nrequires core and the workspace distribution. The packaged JSON uses literal\nPerl commands. All examples ship alongside their own distribution's README\nand logo assets.\n\n## Run repository qualification programs\n\nThe programs in this directory exercise additional contracts through the\nrepository's fixture. Provision the [author environment](../.github/CONTRIBUTING.md#environment)\nfirst. `Future::AsyncAwait` is needed only for `await.pl`.\n\n```console\n$ mise exec -- make examples\n```\n\n| Program | Contract |\n| --- | --- |\n| [quickstart.pl](quickstart.pl) | Select contextual window links, filter captured panes, and verify fixture cleanup. |\n| [selection.pl](selection.pl) | Arrays, callbacks, cardinality, wire filters, relations, retained graphs, and native verification. |\n| [workspace.pl](workspace.pl) | Plan, load, inspect panes, and repeat with `existing => 'skip'`. |\n| [async.pl](async.pl) | Capture through a caller-owned Ppoll loop and await cleanup. |\n| [await.pl](await.pl) | Use optional caller-side `async`/`await` syntax with core result objects. |\n| [async-lifecycle.pl](async-lifecycle.pl) | Preserve failures, handle cancellation, and observe cleanup without destroying a borrowed server. |\n\n`async-lifecycle.pl` also works with installed packages against an existing\nexplicit socket. Run its `--help` before using `--fail` or `--cancel`. A\ncancelled operation does not prove cleanup has finished; continue driving\nthe loop until close succeeds.\n\n## How the examples are checked\n\n[The runner](../scripts/run-examples.pl) rejects nonzero exits and missing\nexpected output. Each live consumer runs with an owned private socket and a\npre-existing sentinel session. After the program exits, the runner verifies\nthat its session is gone and the borrowed session remains. Fixture teardown\nchecks process exit and removes owned files.\n\nThe tmux endpoint CI cells run the same programs. The installed-artifact job\nextracts package examples from the exact native archives, verifies them against\nthe source, and runs them using only the external installation prefix. No\ncheckout module path supplies the consumer's imports.\n\nREADME and guide code blocks marked with `example` come from the complete\nprogram or a named region in it. Check for drift:\n\n```console\n$ mise exec -- make check-snippets\n```\n\nKeep expected output, source, and documentation consistent. The\n[shared capability showcase](https://github.com/libtmux/docs/issues/243)\nrequires executed examples, recorded CI evidence, and an accurate tmux floor.\n"
     },
     {
       "path": "docs/orchestration.md",
-      "content": "---\ntitle: Create and observe tmux resources\ndescription: Create and observe tmux resources with the Perl libtmux distributions.\n---\n\nConstructing `LibTmux::Server` records connection settings without I/O. Pass a\nsocket name or socket path; the library clears inherited `TMUX` and\n`TMUX_PANE` in subprocess environments. Acquisition and mutations are explicit.\n\n```perl\nuse v5.44;\nuse LibTmux::Server;\nmy $server = LibTmux::Server->new(socket_name => 'example');\nmy $session = $server->new_session(\n    name => 'main', command => ['/bin/sleep', '120'],\n);\nmy $window = $server->new_window(\n    session => $session, name => 'api', command => ['/bin/sleep', '120'],\n);\nmy $pane = $window->panes->one;\nmy $split = $server->split_pane(\n    pane => $pane, horizontal => true, command => ['/bin/sleep', '120'],\n);\n$server->select_layout(window => $window, layout => 'even-horizontal');\nmy $observed = $server->snapshot;\n$server->kill_session(session => $session);\n```\n\nThis example creates a session and explicitly removes it. Complete executed\nprograms in [examples](../examples) add exception-safe owned fixture cleanup.\nLiteral argv does not select a shell. `shell_command` explicitly requests\nshell interpretation; one-element literal commands use the core exec shim.\n\nAll mutations live on Server. Entity readers are captured and read-only;\nrenaming a window does not change an old Window handle. Use a new snapshot.\n`capture_pane` returns bytes including tmux's final newline. `send_text`\nsends literal text with optional Enter; `send_keys` accepts named tmux keys.\n\nUse `set_option`/`get_option`/`unset_option` for explicit scopes, including\ninherited reads, and environment methods for global or session values. Hooks\nretain sparse indexes in native output. Buffers use stdin for binary payloads.\n`cmd` is the checked literal command escape hatch; `execute` retains nonzero\ncommand results. Ordered `batch` returns one `{result, error}` record per\nindependent request, not per command inside a tmux command list.\n\nInteractive terminal ownership stays with the caller: `attach_argv` returns\nargv for a caller-owned terminal; `clients` captures client data and\n`detach_client` reports command acceptance. Observe client exit separately.\n\nThe complete [quickstart program](../examples/quickstart.pl) creates a session,\nsplits a pane, adds a window, selects a window link, and filters captured\npanes. Install core first, then run it from the source checkout:\n\n```console\n$ perl examples/quickstart.pl\n```\n\nThe included standard-library fixture owns its private socket and verifies\nchild exit. The standalone demo enables Linux x86_64 LP64 child reaping; the\nborrowed Server connection API does not change the application's reaper.\n"
+      "content": "---\ntitle: Create and observe tmux resources\ndescription: Create sessions, arrange windows, send input, and read captured state from Perl.\n---\n\n## Start with a complete program\n\nAfter [installing core](installation.md), run the\n[standalone quick start](../packages/core/examples/quickstart.pl):\n\n```console\n$ perl packages/core/examples/quickstart.pl \"${TMPDIR:-/tmp}/libtmux-perl-$$.sock\"\n```\n\n<!-- example: packages/core/examples/quickstart.pl -->\n```perl\nuse v5.44;\nuse LibTmux::Server;\n\nmy $socket = shift @ARGV // die \"Usage: $0 SOCKET_PATH [TMUX]\\n\";\nmy $server = LibTmux::Server->new(\n    socket_path => $socket,\n    executable  => shift(@ARGV) // 'tmux',\n    config_file => '/dev/null',\n);\nmy ($session, $snapshot, $failure);\ntry {\n    $session = $server->new_session(\n        name    => 'perl-quickstart',\n        command => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    my $editor = $session->window_links->one->window;\n    $server->rename_window(window => $editor, name => 'editor');\n    $server->split_pane(\n        pane       => $editor->panes->one,\n        horizontal => true,\n        command    => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    $server->new_window(\n        session => $session,\n        name    => 'logs',\n        command => [$^X, '-e', 'while (<STDIN>) { print }'],\n    );\n    $snapshot = $server->snapshot;\n}\ncatch ($error) {\n    $failure = $error;\n    $session //= $error->created if $error isa LibTmux::X::Creation;\n}\nif ($session) {\n    try { $server->kill_session(session => $session) }\n    catch ($cleanup) {\n        warn \"session cleanup failed: $cleanup\\n\";\n        $failure //= $cleanup;\n    }\n}\ndie $failure if defined $failure;\n\n# The captured graph remains readable after its live session has gone.\nfor my $link ($snapshot->session_by_id($session->id)->window_links->@*) {\n    my $count = $link->window->panes->count;\n    say $link->window->name, ': ', $count, $count == 1 ? ' pane' : ' panes';\n}\n```\n\nIt prints `editor: 2 panes` and `logs: 1 pane`. Only the session returned by\ncreation, or its generation-scoped creation receipt, is a cleanup target.\nThe original operation error remains primary if cleanup also fails. Existing\nsessions remain untouched. The captured graph stays readable after removal.\n\nConstructing [Server](https://libtmux.org/en/perl/latest/reference/libtmux-server/)\nrecords connection settings without I/O. `new_session` starts a daemon when\nneeded; `snapshot` requires one to exist. Pass an explicit socket path or name.\nThe core clears inherited `TMUX` and `TMUX_PANE` for subprocesses.\n\n## Arrange a live window\n\nThe [longer workflow](../packages/core/examples/workflow.pl) adds layout\nselection and a second window before capturing:\n\n<!-- example: packages/core/examples/workflow.pl#create -->\n```perl\n$session = $server->new_session(\n    name    => 'perl-workflow',\n    command => [$^X, '-e', 'while (<STDIN>) { print }'],\n);\nmy $editor = $session->window_links->one->window;\n$server->rename_window(window => $editor, name => 'editor');\nmy $right = $server->split_pane(\n    pane       => $editor->panes->one,\n    horizontal => true,\n    command    => [$^X, '-e', 'while (<STDIN>) { print }'],\n);\n$server->select_layout(window => $editor, layout => 'even-horizontal');\nmy $logs = $server->new_window(\n    session => $session,\n    name    => 'logs',\n    command => [$^X, '-e', 'while (<STDIN>) { print }'],\n);\n\n```\n\nRun the complete program with an explicit socket:\n\n```console\n$ perl packages/core/examples/workflow.pl \"${TMPDIR:-/tmp}/libtmux-perl-$$.sock\"\n```\n\nLiteral command arrays do not select a shell. `shell_command` explicitly\nrequests shell interpretation; a one-element literal command uses the core\nexec shim. `even-horizontal` is supported throughout the declared tmux range.\n\n## Send literal text and capture the screen\n\nIn that same live workflow:\n\n<!-- example: packages/core/examples/workflow.pl#input -->\n```perl\n$server->send_text(\n    pane  => $right,\n    text  => 'hello from Perl',\n    enter => true\n);\nmy $screen = $server->capture_pane(pane => $right, start => -100);\nsay 'captured bytes: ', length $screen;\n$server->set_environment(\n    session => $session,\n    name    => 'PROJECT',\n    value   => 'api',\n);\nsay 'PROJECT=',\n    $server->get_environment(session => $session, name => 'PROJECT');\n\n```\n\n`send_text` optionally appends Enter and does not interpret shell syntax.\n`send_keys` accepts tmux key names. `capture_pane` returns bytes including the\nfinal newline; negative `start` values request scrollback. Sending Enter or\naccepting a command does not establish application completion. A read returns\nthe observed screen; use the application's own observable handshake when a\nlater step depends on completed work.\n\n## Read options, environment, and native results\n\nUse `set_option`, `get_option`, and `unset_option` with explicit scope and\ntarget. Inherited option reads must be requested explicitly. Session-scoped\nenvironment operations accept captured handles and check their generation.\nHooks preserve sparse indexes. Buffer operations use stdin for binary payloads.\n\n`cmd` is a checked literal tmux argv escape hatch; `execute` returns nonzero\ncommand results for callers that inspect status themselves. `batch` returns\none `{result, error}` record per independent request, in input order. It does\nnot report individual outcomes inside an arbitrary tmux command list.\n\n## Capture again after a mutation\n\nEntity accessors read captured values; they never refresh or issue a command.\nThe workflow demonstrates a rename without rewriting its old observation:\n\n<!-- example: packages/core/examples/workflow.pl#graph -->\n```perl\nmy $before = $snapshot->window_by_id($logs->id);\n$server->rename_window(window => $logs, name => 'build');\ndie 'captured name changed' unless $before->name eq 'logs';\ndie 'new name missing'\n    unless $server->snapshot->window_by_id($logs->id)->name eq 'build';\nsay 'captured name: ', $before->name;\n\n```\n\nAll mutations live on Server and accept explicit targets. Context-sensitive\nwindow selection, movement, and unlinking use WindowLink targets. Interactive\nterminal ownership stays with the caller: `attach_argv` returns argv;\n`detach_client` reports command acceptance, not observed client exit.\nSee [graph identity](graph.md), [filtering](filtering.md), and\n[errors and recovery](errors.md).\n"
     },
     {
       "path": "docs/graph.md",
-      "content": "---\ntitle: Snapshots and linked-window identity\ndescription: Snapshots and linked-window identity with the Perl libtmux distributions.\n---\n\nA physical window can appear at several indexes in one session and in several\nsessions. `WindowLink` owns session-relative index and active state. A Pane's\n`window` always returns the physical Window. Session changes use explicit links.\n\nSnapshot `windows` and `panes` contain each physical identity once. Raw\n`listings` retain contextual rows and multiplicity. Selection filters retain\ntheir own input order and duplicates. Two occurrences of one identity still\nmake `one` ambiguous.\n\nSelections may combine captures from the same server generation. Each handle\nretains its own observed graph; combining them does not reconcile capture times\nor create a new snapshot. Mixing server scopes or daemon generations is an\n`InvalidSelection` error. Use one snapshot when a query needs one capture interval.\nFor example, a retained pane captured before a rename and a fresh pane with\nthe same resource identity can expose different window names. Each traverses\nits own graph. Capture start/end metadata describes those observation intervals;\nresource identity alone does not identify an observation.\n\nIDs remain strings. Write session IDs as `'$1'` in Perl so regex captures do\nnot interpolate. Identity includes server, daemon generation, kind, and ID.\nCaptured handles prevent silent retargeting after a restart; probes and\ncommands remain separate observations, so they do not form a transaction.\nThe daemon's `socket_path` identifies the server and `pid/start_time` its\ngeneration. Raw ID strings deliberately target current resources and convey\nno historical generation protection.\n\nThe store owns scalar records and ID adjacency. Handles strongly retain that\nstore, which does not strongly own handles. A retained pane keeps its observed\nwindow even when the Snapshot wrapper leaves scope. Retaining one handle can\nretain the graph; `to_record` exports detached scalar data instead.\nCurrent to-many accessors scan related records; repeated relation traversal\ncan repeat that work. Retained-graph memory and indexing improvements require\nmeasurements rather than assumptions about typical tmux graph size.\n\nAcquisition records start/end and completeness. Strict live capture rejects\nmissing required topology. Unloaded fields and relations throw when needed;\nnull and loaded-empty relations remain distinct. Accessors return independent\nmembership arrays. Query methods are nonmutating, while native arrays remain\nmutable and every library query validates their members.\n"
+      "content": "---\ntitle: Snapshots and linked-window identity\ndescription: Snapshots and linked-window identity with the Perl libtmux distributions.\n---\n\nA physical window can appear at several indexes in one session and in several\nsessions. `WindowLink` owns session-relative index and active state. A Pane's\n`window` always returns the physical Window. Session changes use explicit links.\n\nSnapshot `windows` and `panes` contain each physical identity once. Raw\n`listings` retain contextual rows and multiplicity. Selection filters retain\ntheir own input order and duplicates. Two occurrences of one identity still\nmake `one` ambiguous.\n\nSelections may combine captures from the same server generation. Each handle\nretains its own observed graph; combining them does not reconcile capture times\nor create a new snapshot. Mixing server scopes or daemon generations is an\n`InvalidSelection` error. Use one snapshot when a query needs one capture interval.\nFor example, a retained pane captured before a rename and a fresh pane with\nthe same resource identity can expose different window names. Each traverses\nits own graph. Capture start/end metadata describes those observation intervals;\nresource identity alone does not identify an observation.\n\nIDs remain strings. Write session IDs as `'$1'` in Perl so regex captures do\nnot interpolate. Identity includes server, daemon generation, kind, and ID.\nCaptured handles prevent silent retargeting after a restart; probes and\ncommands remain separate observations, so they do not form a transaction.\nThe daemon's `socket_path` identifies the server and `pid/start_time` its\ngeneration. Raw ID strings deliberately target current resources and convey\nno historical generation protection.\n\nThe store owns scalar records and ID adjacency. Handles strongly retain that\nstore, which does not strongly own handles. A retained pane keeps its observed\nwindow even when the Snapshot wrapper leaves scope. Retaining one handle can\nretain the graph; `to_record` exports detached scalar data instead.\nCurrent to-many accessors scan related records; repeated relation traversal\ncan repeat that work. Retained-graph memory and indexing improvements require\nmeasurements rather than assumptions about typical tmux graph size.\n\nAcquisition records start/end and completeness. Strict live capture rejects\nmissing required topology. Unloaded fields and relations throw when needed;\nnull and loaded-empty relations remain distinct. Accessors return independent\nmembership arrays. Query methods are nonmutating, while native arrays remain\nmutable and every library query validates their members.\n\n## Observe a rename without rewriting history\n\nThe [standalone workflow](../packages/core/examples/workflow.pl) retains the\n`logs` window from one capture, renames its live counterpart, and checks both\nobservations:\n\n<!-- example: packages/core/examples/workflow.pl#graph -->\n```perl\nmy $before = $snapshot->window_by_id($logs->id);\n$server->rename_window(window => $logs, name => 'build');\ndie 'captured name changed' unless $before->name eq 'logs';\ndie 'new name missing'\n    unless $server->snapshot->window_by_id($logs->id)->name eq 'build';\nsay 'captured name: ', $before->name;\n\n```\n\nThe old handle still says `logs`; a new capture says `build`. The core quick\nstart also traverses its retained graph after removing its live session.\nBoth programs use only installed public modules and explicit sockets.\n"
     },
     {
       "path": "docs/fields.md",
@@ -34,11 +34,11 @@
     },
     {
       "path": "docs/query-planning.md",
-      "content": "---\ntitle: Explicit acquisition and native filters\ndescription: Explicit acquisition and native filters with the Perl libtmux distributions.\n---\n\n`$snapshot->panes->where($criteria)` and callbacks evaluate eagerly without\nI/O. `query_panes` explicitly acquires a graph and returns a PaneSelection.\n`explain_panes` creates a local plan using support-floor capabilities; it does\nnot connect. Execution binds capabilities to the captured daemon generation.\n\n| Policy | Behavior |\n| --- | --- |\n| `never` | Acquire and evaluate locally. |\n| `auto` | Verify safe scalar native candidates; fall back to captured local results on disagreement. |\n| `require` | Require complete exact lowering and native/captured agreement. |\n\nThe current implementation captures and evaluates the complete graph before\ncandidate verification, preserving local error behavior. It makes no I/O-saving\nclaim. Plans identify commands, lowered filters, residual reasons, and capability\nrequirements. Numeric lowering uses tmux numeric expressions. Literal operands\nare escaped for the tmux grammar independently of argument-vector safety.\n\n`auto` is the default. It costs an extra command and supervisor when lowering\nis available. Select `never` when only the captured answer is needed. To inspect\nthe comparison, supply `on_verification => sub ($report) { ... }`. The observer\nreceives one detached hashref in void context; its return is ignored. It runs\ninline once after a successful decision, including fallback. Exceptions\npropagate unchanged unless the operation has already been cancelled;\ncancellation suppresses subsequent result/error delivery.\nFailed acquisition, decoding or native commands do not\ninvoke it and remain failures.\n\nThe report identifies `status`, `comparison`, capture generation/interval,\nexecuted filter, residual reasons, and captured/local/native ID arrays.\n`disabled` means `never`, and `local` means no safe lowering was available.\n`agreed` distinguishes exact equality from partial candidate inclusion;\n`disagreed` lists missing, unexpected and uncaptured IDs. `native` reports only\ncaptured membership for the expert escape hatch. See\n[`Server`'s report contract](../packages/core/lib/LibTmux/Server.pm)\nand the [tested query example](../examples/selection.pl).\n\n`require` disagreement throws `LibTmux::X::QueryMismatch`, with the report under\nthe `verification` key returned by `LibTmux::X::details`. The observer does not\nrun before that failure.\nA mismatch can reflect a race, a compiler defect or a backend difference;\nit does not establish which occurred. Matching observations also do not prove\nan atomic capture. [ADR 0003](dev/adr/0003-query-verification-diagnostics.md)\nrecords the diagnostic and default-policy decision.\n\nA partial AND conjunct can prune candidates. Partial OR/NOT cannot. Relations,\nnull, bytes, and unsupported scalar operators remain local. Relation pushdown\nand serialized regex dialects are deferred. Complete relation domains are never\npruned before `every` or `none` evaluation.\n\n`native_filter` is an explicit expert escape hatch, exclusive with portable\ncriteria and pushdown policy. It selects captured root IDs and rejects new IDs\nthat appeared outside capture. It has native tmux semantics, not wire semantics.\n"
+      "content": "---\ntitle: Explicit acquisition and native filters\ndescription: Explicit acquisition and native filters with the Perl libtmux distributions.\n---\n\n`$snapshot->panes->where($criteria)` and callbacks evaluate eagerly without\nI/O. `query_panes` explicitly acquires a graph and returns a PaneSelection.\n`explain_panes` creates a local plan using support-floor capabilities; it does\nnot connect. Execution binds capabilities to the captured daemon generation.\n\nThe [installed-package workflow](../packages/core/examples/workflow.pl)\ncompares local evaluation and exact native verification on a controlled graph:\n\n<!-- example: packages/core/examples/workflow.pl#query -->\n```perl\nmy $where = {active => true, width => {-gte => 1}};\nmy $local = $server->query_panes(where => $where, pushdown => 'never');\nmy $verification;\nmy $verified = $server->query_panes(\n    where           => $where,\n    pushdown        => 'require',\n    on_verification => sub ($report) { $verification = $report },\n);\nsay 'native verification: ', $verification->{status};\n\n```\n\n`never` still performs acquisition; it disables the extra native candidate\ncheck. The result of either call is a captured local selection. The example\nchecks identical IDs and observes `native verification: agreed`.\n\n| Policy | Behavior |\n| --- | --- |\n| `never` | Acquire and evaluate locally. |\n| `auto` | Verify safe scalar native candidates; fall back to captured local results on disagreement. |\n| `require` | Require complete exact lowering and native/captured agreement. |\n\nThe current implementation captures and evaluates the complete graph before\ncandidate verification, preserving local error behavior. It makes no I/O-saving\nclaim. Plans identify commands, lowered filters, residual reasons, and capability\nrequirements. Numeric lowering uses tmux numeric expressions. Literal operands\nare escaped for the tmux grammar independently of argument-vector safety.\n\n`auto` is the default. It costs an extra command and supervisor when lowering\nis available. Select `never` when only the captured answer is needed. To inspect\nthe comparison, supply `on_verification => sub ($report) { ... }`. The observer\nreceives one detached hashref in void context; its return is ignored. It runs\ninline once after a successful decision, including fallback. Exceptions\npropagate unchanged unless the operation has already been cancelled;\ncancellation suppresses subsequent result/error delivery.\nFailed acquisition, decoding or native commands do not\ninvoke it and remain failures.\n\nThe report identifies `status`, `comparison`, capture generation/interval,\nexecuted filter, residual reasons, and captured/local/native ID arrays.\n`disabled` means `never`, and `local` means no safe lowering was available.\n`agreed` distinguishes exact equality from partial candidate inclusion;\n`disagreed` lists missing, unexpected and uncaptured IDs. `native` reports only\ncaptured membership for the expert escape hatch. See\n[`Server`'s report contract](../packages/core/lib/LibTmux/Server.pm)\nand the [tested query example](../examples/selection.pl).\n\n`require` disagreement throws `LibTmux::X::QueryMismatch`, with the report under\nthe `verification` key returned by `LibTmux::X::details`. The observer does not\nrun before that failure.\nA mismatch can reflect a race, a compiler defect or a backend difference;\nit does not establish which occurred. Matching observations also do not prove\nan atomic capture. [ADR 0003](dev/adr/0003-query-verification-diagnostics.md)\nrecords the diagnostic and default-policy decision.\n\nA partial AND conjunct can prune candidates. Partial OR/NOT cannot. Relations,\nnull, bytes, and unsupported scalar operators remain local. Relation pushdown\nand serialized regex dialects are deferred. Complete relation domains are never\npruned before `every` or `none` evaluation.\n\n`native_filter` is an explicit expert escape hatch, exclusive with portable\ncriteria and pushdown policy. It selects captured root IDs and rejects new IDs\nthat appeared outside capture. It has native tmux semantics, not wire semantics.\n"
     },
     {
       "path": "docs/errors.md",
-      "content": "---\ntitle: Recover from failures\ndescription: Recover from failures with the Perl libtmux distributions.\n---\n\nErrors are typed `LibTmux::X` objects with readable stringification and\napplicable fields such as path, expected/received types, IDs, dispatch state,\nand process result. Catch objects with stable Perl try/catch and isa:\n\n```perl\ntry {\n    my $only = $snapshot->panes->one({ active => true });\n}\ncatch ($error) {\n    if ($error isa LibTmux::X::NoMatch) {\n        say 'No active pane in this captured selection';\n    }\n    else {\n        die $error;\n    }\n}\n```\n\n`one_or_undef` handles absence and still rejects ambiguity. Acquisition errors\nnever become empty selections. `Unloaded` differs from known null. Complete\ncriteria validation runs before matching, including on empty input and in\nbranches that later short-circuit.\n\nProcess results distinguish stdout, stderr, exit status, signal, timeout,\nspawn failure, output limit, cancellation, and dispatch uncertainty. Lifecycle\nerrors retain bounded partial results; unknown status remains undef.\nCancellation does not imply rollback or nonexecution. The isolated Linux\nsupervisor reaps its owned process group; intentionally detached daemons have\nseparate ownership. The current verified ABI is x86_64 LP64.\n\nOwned supervisor and command branches close unrelated inherited descriptors,\nincluding native descriptors without close-on-exec. The caller's handles stay\nopen. Only standard streams and the job's explicit protocol/cancellation pipes\nsurvive where needed; a newly started tmux daemon cannot retain an unrelated\ncaller file or socket. This requires the Linux `/proc/self/fd` interface.\nDescriptor enumeration/closure failure prevents dispatch and remains a typed\ntransport or spawn failure. Forking a host with native threads is unqualified.\n\nTransport `timeout` bounds one command's execution loop, excluding supervisor\nsetup and async queue waiting. A snapshot runs several commands, each with its\nown timeout; this setting is not a total snapshot deadline. Cleanup has a\nseparate allowance and continues after useful work expires. Async callers must\ndrive the borrowed loop until successful close-observer completion. Cancelling\nthe observer or stopping the loop does not prove that processes have exited.\n\n`Creation` preserves a generation-scoped minimal created handle when the\ncommand succeeded but subsequent capture failed. Inspect `created` and `cause`\nbefore deciding cleanup. Other fields on that handle are unloaded. Workspace\nuses this evidence for owned rollback and records cleanup failures separately.\n"
+      "content": "---\ntitle: Recover from failures\ndescription: Recover from failures with the Perl libtmux distributions.\n---\n\nErrors are typed `LibTmux::X` objects with readable stringification and\napplicable fields such as path, expected/received types, IDs, dispatch state,\nand process result. Catch objects with stable Perl try/catch and isa:\n\n```perl\ntry {\n    my $only = $snapshot->panes->one({ active => true });\n}\ncatch ($error) {\n    if ($error isa LibTmux::X::NoMatch) {\n        say 'No active pane in this captured selection';\n    }\n    else {\n        die $error;\n    }\n}\n```\n\n`one_or_undef` handles absence and still rejects ambiguity. Acquisition errors\nnever become empty selections. `Unloaded` differs from known null. Complete\ncriteria validation runs before matching, including on empty input and in\nbranches that later short-circuit.\n\nProcess results distinguish stdout, stderr, exit status, signal, timeout,\nspawn failure, output limit, cancellation, and dispatch uncertainty. Lifecycle\nerrors retain bounded partial results; unknown status remains undef.\nCancellation does not imply rollback or nonexecution. The isolated Linux\nsupervisor reaps its owned process group; intentionally detached daemons have\nseparate ownership. The current verified ABI is x86_64 LP64.\n\nOwned supervisor and command branches close unrelated inherited descriptors,\nincluding native descriptors without close-on-exec. The caller's handles stay\nopen. Only standard streams and the job's explicit protocol/cancellation pipes\nsurvive where needed; a newly started tmux daemon cannot retain an unrelated\ncaller file or socket. This requires the Linux `/proc/self/fd` interface.\nDescriptor enumeration/closure failure prevents dispatch and remains a typed\ntransport or spawn failure. Forking a host with native threads is unqualified.\n\nTransport `timeout` bounds one command's execution loop, excluding supervisor\nsetup and async queue waiting. A snapshot runs several commands, each with its\nown timeout; this setting is not a total snapshot deadline. Cleanup has a\nseparate allowance and continues after useful work expires. Async callers must\ndrive the borrowed loop until successful close-observer completion. Cancelling\nthe observer or stopping the loop does not prove that processes have exited.\n\n`Creation` preserves a generation-scoped minimal created handle when the\ncommand succeeded but subsequent capture failed. Inspect `created` and `cause`\nbefore deciding cleanup. Other fields on that handle are unloaded. Workspace\nuses this evidence for owned rollback and records cleanup failures separately.\n\n## Report an invalid filter without losing its type\n\nThe [record-only example](../packages/core/examples/filters.pl) runs without a\ntmux server and rejects a text operand for an integer field:\n\n<!-- example: packages/core/examples/filters.pl#invalid -->\n```perl\ntry {\n    LibTmux::Filter->new(\n        entity => 'pane',\n        where  => {width => {-gte => 'wide'}}\n    );\n    die 'invalid numeric operand was accepted';\n}\ncatch ($error) {\n    die $error unless $error isa LibTmux::X::InvalidFilter;\n    say 'invalid operand at ', $error->path;\n    say 'expected: ',          $error->expected;\n}\n\n```\n\nThe path is `pane.where.width.-gte`, and `expected` says `safe decimal integer`.\nUse the typed [InvalidFilter](https://libtmux.org/en/perl/latest/reference/libtmux-x/)\nexception and its fields to choose recovery; stringification is for a readable\ndiagnostic. Unknown fields and malformed filters fail before examining any\nselection members, including on an empty selection.\n\nThe [core quick start](../packages/core/examples/quickstart.pl) separately\nshows creation receipts and exception-safe session cleanup. The\n[async consumer](../packages/async/examples/concurrent.pl) awaits executor\ncleanup even after an operation fails. A cleanup failure never replaces the\noriginal operation failure in either example.\n"
     },
     {
       "path": "docs/compatibility.md",
@@ -46,11 +46,11 @@
     },
     {
       "path": "docs/async.md",
-      "content": "---\ntitle: Optional Future execution\ndescription: Optional Future execution with the Perl libtmux distributions.\n---\n\nInstall the separate LibTmux-Async distribution to use an injected\n[`IO::Async::Loop::Ppoll`](https://metacpan.org/pod/IO::Async::Loop::Ppoll) and a Future-returning\nServer facade. Core and workspace do not load this dependency. Caller-side\nFuture::AsyncAwait syntax is optional.\n\nConstruct `IO::Async::Loop::Ppoll->new` explicitly. Installing it does not\nforce `IO::Async::Loop->new` to select it. Other backends are rejected before\ndispatch. The async distribution requires Ppoll 0.10 and IO::Ppoll 0.14 or\nnewer; IO::Ppoll supplies the native atomic-wait extension. Core and workspace\nremain standard-library runtime distributions.\n\nThe caller owns and drives the loop. Each operation resolves to one value;\nvoid methods yield one undef. Command preparation, framing, identity, and\nparsing are shared with core. Captured selections stay synchronous and local.\n\nTransport bounds concurrent jobs and pending requests. Queue overflow fails\nbefore dispatch. Cancellation suppresses subsequent continuations and requests\ncleanup; it cannot undo accepted effects. Close cancels queued/running work,\nrejects new admissions, and returns a fresh cleanup observer. Only successful\n`is_done` proves cleanup. Cancelling that observer cannot cancel private cleanup.\nKeep driving the borrowed loop through shutdown; closing preserves the server.\n\nPpoll owns the host's signal-watching policy. It blocks watched signals outside\nits atomic wait and can retain its shared `SIGCHLD` watch after facade close.\nDo not change its backend or wait mask while requests or cleanup remain active.\nAsync children unblock only `SIGCHLD`, so a newly started tmux daemon can reap\nits panes; other mask bits remain unchanged in the child. Synchronous core\nexecution retains the caller's mask. Starting a daemon through synchronous\ncore while the host blocks `SIGCHLD` also passes that blocked mask to the daemon.\nSee [ADR 0004](dev/adr/0004-atomic-async-child-exit.md) for the failure evidence\nand the alternatives considered.\n\nThe default bounds are four active jobs and 64 queued requests. A command's\ntimeout starts in its execution loop, after queue waiting and supervisor setup.\nIt does not bound the total time of a multi-command operation. Cleanup has a\nseparate allowance; see [failure recovery](errors.md).\n\nPersistent control, streaming subscriptions, and tmux command lists are deferred.\nOrdered batch requests are independent submissions with individual attribution.\n\n## Failure and cancellation\n\n[async-lifecycle.pl](../examples/async-lifecycle.pl) is a standalone downstream\nprogram. It imports only installed distributions and Perl core modules; it\ndoes not use the repository fixture. Supply the socket path of an existing\ntmux server. The program observes that server and closes only its executor.\n`--fail` exercises a rejected native command; `--cancel` cancels the capture.\n\nThe program always drives cleanup to completion. An operation failure remains\nthe primary exception, while a secondary cleanup failure is reported\nseparately. Cancellation is checked before `get`; it is readiness without a\nresult and does not prove cleanup. A successful close observer supplies that\nproof. The repository example runner exercises all three paths against an\nowned server, including with an isolated installed package prefix.\n\n<!-- example: async-lifecycle.pl -->\n```perl\nuse v5.44;\nuse Getopt::Long qw(GetOptions);\nuse IO::Async::Loop::Ppoll;\nuse LibTmux::Async::Server;\n\nmy ($socket, $executable, $fail, $cancel, $help);\nGetOptions(\n    'socket=s' => \\$socket,\n    'tmux=s'   => \\$executable,\n    'fail'     => \\$fail,\n    'cancel'   => \\$cancel,\n    'help'     => \\$help,\n) or die \"Use --help for arguments\\n\";\nif ($help) {\n    say\n'Usage: perl async-lifecycle.pl --socket PATH [--tmux EXE] [--fail | --cancel]';\n    say\n'Observe an existing server and close the executor without destroying that server.';\n    exit 0;\n}\ndie \"Supply --socket PATH; --fail and --cancel are mutually exclusive\\n\"\n    if !defined($socket) || @ARGV || ($fail && $cancel);\n\nmy $loop   = IO::Async::Loop::Ppoll->new;\nmy $server = LibTmux::Async::Server->new(\n    loop        => $loop,\n    socket_path => $socket,\n    defined($executable) ? (executable => $executable) : (),\n);\nmy ($operation_error, $cleanup_error);\ntry {\n    my $operation =\n          $fail\n        ? $server->cmd('libtmux-example-invalid-command')\n        : $server->snapshot;\n    $operation->cancel if $cancel;\n    $loop->await($operation);\n    if ($operation->is_cancelled) { say 'capture cancelled' }\n    else {\n        my $snapshot = $operation->get;\n        say 'captured panes: ' . $snapshot->panes->count;\n    }\n}\ncatch ($error) { $operation_error = $error }\n\ntry {\n    my $cleanup = $server->close;\n    $loop->await($cleanup);\n    $cleanup->get;\n    say 'executor cleanup: complete';\n}\ncatch ($error) { $cleanup_error = $error }\n\nif (defined $operation_error) {\n    warn \"executor cleanup also failed: $cleanup_error\\n\"\n        if defined $cleanup_error;\n    die $operation_error;\n}\ndie $cleanup_error if defined $cleanup_error;\n```\n"
+      "content": "---\ntitle: Optional Future execution\ndescription: Optional Future execution with the Perl libtmux distributions.\n---\n\nInstall the separate LibTmux-Async distribution to use an injected\n[`IO::Async::Loop::Ppoll`](https://metacpan.org/pod/IO::Async::Loop::Ppoll) and a Future-returning\nServer facade. Core and workspace do not load this dependency. Caller-side\nFuture::AsyncAwait syntax is optional.\n\nConstruct `IO::Async::Loop::Ppoll->new` explicitly. Installing it does not\nforce `IO::Async::Loop->new` to select it. Other backends are rejected before\ndispatch. The async distribution requires Ppoll 0.10 and IO::Ppoll 0.14 or\nnewer; IO::Ppoll supplies the native atomic-wait extension. Core and workspace\nremain standard-library runtime distributions.\n\nThe caller owns and drives the loop. Each operation resolves to one value;\nvoid methods yield one undef. Command preparation, framing, identity, and\nparsing are shared with core. Captured selections stay synchronous and local.\n\nTransport bounds concurrent jobs and pending requests. Queue overflow fails\nbefore dispatch. Cancellation suppresses subsequent continuations and requests\ncleanup; it cannot undo accepted effects. Close cancels queued/running work,\nrejects new admissions, and returns a fresh cleanup observer. Only successful\n`is_done` proves cleanup. Cancelling that observer cannot cancel private cleanup.\nKeep driving the borrowed loop through shutdown; closing preserves the server.\n\nPpoll owns the host's signal-watching policy. It blocks watched signals outside\nits atomic wait and can retain its shared `SIGCHLD` watch after facade close.\nDo not change its backend or wait mask while requests or cleanup remain active.\nAsync children unblock only `SIGCHLD`, so a newly started tmux daemon can reap\nits panes; other mask bits remain unchanged in the child. Synchronous core\nexecution retains the caller's mask. Starting a daemon through synchronous\ncore while the host blocks `SIGCHLD` also passes that blocked mask to the daemon.\nSee [ADR 0004](dev/adr/0004-atomic-async-child-exit.md) for the failure evidence\nand the alternatives considered.\n\nThe default bounds are four active jobs and 64 queued requests. A command's\ntimeout starts in its execution loop, after queue waiting and supervisor setup.\nIt does not bound the total time of a multi-command operation. Cleanup has a\nseparate allowance; see [failure recovery](errors.md).\n\nPersistent control, streaming subscriptions, and tmux command lists are deferred.\nOrdered batch requests are independent submissions with individual attribution.\n\n## Run concurrent operations\n\nAfter installing core and async, run the standalone packaged program:\n\n```console\n$ perl packages/async/examples/concurrent.pl \"${TMPDIR:-/tmp}/libtmux-perl-async-$$.sock\"\n```\n\nIt creates and removes its own session and preserves any other sessions on that\nsocket. During its live scope it starts independent operations before awaiting\nboth results:\n\n<!-- example: packages/async/examples/concurrent.pl#concurrent -->\n```perl\nmy $capture = $server->snapshot;\nmy $version = $server->cmd('display-message', '-p', '#{version}');\n$loop->await(Future->needs_all($capture, $version));\nmy $snapshot = $capture->get;\nmy $panes    = $snapshot->sessions->one({name => 'perl-async'})\n    ->window_links->one->window->panes->where({active => true});\nsay 'async active panes: ', $panes->count;\nsay 'tmux version: ',       $version->get->stdout;\n\n```\n\nSelections returned by the capture are ordinary synchronous core objects.\nThe same program also checks ordered independent requests:\n\n<!-- example: packages/async/examples/concurrent.pl#batch -->\n```perl\nmy $batch = $server->batch(\n    [\n        ['display-message', '-p', 'first'],\n        ['display-message', '-p', 'second'],\n    ]\n);\n$loop->await($batch);\nmy $results = $batch->get;\nfor my $entry ($results->@*) {\n    die $entry->{error} if defined $entry->{error};\n    print $entry->{result}->stdout;\n}\n\n```\n\nThe [complete source](../packages/async/examples/concurrent.pl) owns session\ncleanup, preserves primary errors, and awaits executor close. It uses installed\npackages without Python or a repository fixture.\n\n## Failure and cancellation\n\n[async-lifecycle.pl](../examples/async-lifecycle.pl) is a standalone downstream\nprogram. It imports only installed distributions and Perl core modules; it\ndoes not use the repository fixture. Supply the socket path of an existing\ntmux server. The program observes that server and closes only its executor.\n`--fail` exercises a rejected native command; `--cancel` cancels the capture.\n\nThe program always drives cleanup to completion. An operation failure remains\nthe primary exception, while a secondary cleanup failure is reported\nseparately. Cancellation is checked before `get`; it is readiness without a\nresult and does not prove cleanup. A successful close observer supplies that\nproof. The repository example runner exercises all three paths against an\nowned server, including with an isolated installed package prefix.\n\n<!-- example: async-lifecycle.pl -->\n```perl\nuse v5.44;\nuse Getopt::Long qw(GetOptions);\nuse IO::Async::Loop::Ppoll;\nuse LibTmux::Async::Server;\n\nmy ($socket, $executable, $fail, $cancel, $help);\nGetOptions(\n    'socket=s' => \\$socket,\n    'tmux=s'   => \\$executable,\n    'fail'     => \\$fail,\n    'cancel'   => \\$cancel,\n    'help'     => \\$help,\n) or die \"Use --help for arguments\\n\";\nif ($help) {\n    say\n'Usage: perl async-lifecycle.pl --socket PATH [--tmux EXE] [--fail | --cancel]';\n    say\n'Observe an existing server and close the executor without destroying that server.';\n    exit 0;\n}\ndie \"Supply --socket PATH; --fail and --cancel are mutually exclusive\\n\"\n    if !defined($socket) || @ARGV || ($fail && $cancel);\n\nmy $loop   = IO::Async::Loop::Ppoll->new;\nmy $server = LibTmux::Async::Server->new(\n    loop        => $loop,\n    socket_path => $socket,\n    defined($executable) ? (executable => $executable) : (),\n);\nmy ($operation_error, $cleanup_error);\ntry {\n    my $operation =\n          $fail\n        ? $server->cmd('libtmux-example-invalid-command')\n        : $server->snapshot;\n    $operation->cancel if $cancel;\n    $loop->await($operation);\n    if ($operation->is_cancelled) { say 'capture cancelled' }\n    else {\n        my $snapshot = $operation->get;\n        say 'captured panes: ' . $snapshot->panes->count;\n    }\n}\ncatch ($error) { $operation_error = $error }\n\ntry {\n    my $cleanup = $server->close;\n    $loop->await($cleanup);\n    $cleanup->get;\n    say 'executor cleanup: complete';\n}\ncatch ($error) { $cleanup_error = $error }\n\nif (defined $operation_error) {\n    warn \"executor cleanup also failed: $cleanup_error\\n\"\n        if defined $cleanup_error;\n    die $operation_error;\n}\ndie $cleanup_error if defined $cleanup_error;\n```\n"
     },
     {
       "path": "docs/workspace.md",
-      "content": "---\ntitle: Load a JSON workspace\ndescription: Load a JSON workspace with the Perl libtmux distributions.\n---\n\nThe separate distribution packages the `libtmux-workspace` CLI. Validate and\nplan without tmux I/O; load explicitly through public core APIs.\n\n```json\n{\n  \"schema\": \"libtmux.workspace/v1\",\n  \"sessions\": [{\n    \"name\": \"main\",\n    \"windows\": [{\n      \"name\": \"api\",\n      \"layout\": \"even-horizontal\",\n      \"panes\": [\n        {\"command\": [\"/bin/sleep\", \"120\"]},\n        {\"command\": [\"/bin/sleep\", \"120\"], \"horizontal\": true}\n      ]\n    }]\n  }]\n}\n```\n\n```console\n$ libtmux-workspace validate workspace.json\n```\n\n```console\n$ libtmux-workspace plan workspace.json\n```\n\n```console\n$ libtmux-workspace load workspace.json \\\n    --socket-name example \\\n    --existing skip\n```\n\n`--dry-run` selects a nonmutating plan. Default `existing=error` checks all\nsession-name conflicts before creation. `skip` preserves the entire existing\nsession; repeated loads create only absent sessions. This is not convergence\nor reconciliation of an existing layout.\n\nEach pane requires literal `command` argv or explicit `shell_command`.\nEnvironment inherits workspace → session → window → pane; cwd inherits from\nwindow unless overridden. Layout applies after splitting. Configuration is\nversioned JSON; no YAML adapter or MCP consumer is selected.\n\nOn failure, inspect completed steps, failed step, created IDs, dispatch\nuncertainty, and cleanup errors. Rollback targets only sessions proven created\nby this invocation. Application readiness requires caller-specific assertions.\nCLI exit statuses: success 0; usage/configuration 2; loading 3; conflict 4.\n\n`LibTmux::Workspace::X::Load->report` retains each cleanup exception with its\ncaptured target identity and attempted action. These entries replace the\nearlier string-only `cleanup_errors` values. `cause` remains the original load\nfailure; a cleanup failure never replaces it. Catch and inspect the exception\nclass, dispatch evidence, and bounded native result when choosing recovery.\n\n`report_data` returns a detached diagnostic export for JSON, including the\nprimary cause and cleanup error classes. Native stdout/stderr use explicit\nbase64 fields to preserve arbitrary octets. The CLI prints this export on\nstandard error; the library report keeps the original exception objects.\n"
+      "content": "---\ntitle: Load a JSON workspace\ndescription: Load a JSON workspace with the Perl libtmux distributions.\n---\n\nThe separate distribution packages the `libtmux-workspace` CLI. Validate and\nplan without tmux I/O; load explicitly through public core APIs.\n\nSave [the packaged configuration](../packages/workspace/examples/workspace.json)\nas `workspace.json`, or use that file from the checkout. Its commands are Perl\nprograms, with two editor panes and a logs window:\n\n<!-- example: packages/workspace/examples/workspace.json -->\n```json\n{\n  \"schema\": \"libtmux.workspace/v1\",\n  \"environment\": {\"PROJECT\": \"api\"},\n  \"sessions\": [{\n    \"name\": \"perl-workspace\",\n    \"windows\": [{\n      \"name\": \"editor\",\n      \"layout\": \"even-horizontal\",\n      \"panes\": [\n        {\"command\": [\"perl\", \"-e\", \"while (<STDIN>) { print }\"]},\n        {\"command\": [\"perl\", \"-e\", \"while (<STDIN>) { print }\"], \"horizontal\": true}\n      ]\n    }, {\n      \"name\": \"logs\",\n      \"panes\": [{\"command\": [\"perl\", \"-e\", \"while (<STDIN>) { print }\" ]}]\n    }]\n  }]\n}\n```\n\nFrom the repository root:\n\n```console\n$ libtmux-workspace validate packages/workspace/examples/workspace.json\n```\n\n```console\n$ libtmux-workspace plan packages/workspace/examples/workspace.json\n```\n\n```console\n$ libtmux-workspace load packages/workspace/examples/workspace.json \\\n    --socket-path \"${TMPDIR:-/tmp}/libtmux-perl-workspace-$$.sock\" \\\n    --existing skip\n```\n\nLoading leaves the workspace running. The\n[standalone Perl example](../packages/workspace/examples/load.pl) additionally\nchecks the resulting graph, repeats with `skip`, and removes its own session:\n\n```console\n$ perl packages/workspace/examples/load.pl \"${TMPDIR:-/tmp}/libtmux-perl-workspace-$$.sock\"\n```\n\nIts plan is local and performs no tmux I/O:\n\n<!-- example: packages/workspace/examples/load.pl#plan -->\n```perl\nopen my $in, '<:raw', \"$FindBin::Bin/workspace.json\" or die $!;\nmy $json = do { local $/; <$in> };\nclose $in or die $!;\nmy $workspace = LibTmux::Workspace->from_json($json);\nmy $plan      = $workspace->plan;\nsay 'planned sessions: ', scalar $plan->{sessions}->@*;\ndie 'plan must not mutate' if $plan->{mutates};\n\n```\n\nIt then loads and inspects captured public core objects:\n\n<!-- example: packages/workspace/examples/load.pl#load -->\n```perl\nmy $report   = $workspace->load(server => $server);\nmy $snapshot = $server->snapshot;\n$session = $snapshot->sessions->one({name => 'perl-workspace'});\nmy $windows = $session->window_links;\nsay 'loaded windows: ', $windows->count;\nmy $editor = $windows->one({window => {-is => {name => 'editor'}}})->window;\nsay 'editor panes: ', $editor->panes->count;\n\n```\n\nRepeating with `skip` preserves the whole existing session:\n\n<!-- example: packages/workspace/examples/load.pl#repeat -->\n```perl\nmy $again = $workspace->load(server => $server, existing => 'skip');\nsay 'skipped existing sessions: ', scalar $again->{skipped}->@*;\n\n```\n\nThe complete program imports installed modules and reads its adjacent JSON;\nit needs no author helper. Its output confirms one planned session, two loaded\nwindows, two editor panes, and one skipped session.\n\n`--dry-run` selects a nonmutating plan. Default `existing=error` checks all\nsession-name conflicts before creation. `skip` preserves the entire existing\nsession; repeated loads create only absent sessions. This is not convergence\nor reconciliation of an existing layout.\n\nEach pane requires literal `command` argv or explicit `shell_command`.\nEnvironment inherits workspace → session → window → pane; cwd inherits from\nwindow unless overridden. Layout applies after splitting. Configuration is\nversioned JSON; no YAML adapter is selected.\n\nOn failure, inspect completed steps, failed step, created IDs, dispatch\nuncertainty, and cleanup errors. Rollback targets only sessions proven created\nby this invocation. Application readiness requires caller-specific assertions.\nCLI exit statuses: success 0; usage/configuration 2; loading 3; conflict 4.\n\n`LibTmux::Workspace::X::Load->report` retains each cleanup exception with its\ncaptured target identity and attempted action. These entries replace the\nearlier string-only `cleanup_errors` values. `cause` remains the original load\nfailure; a cleanup failure never replaces it. Catch and inspect the exception\nclass, dispatch evidence, and bounded native result when choosing recovery.\n\n`report_data` returns a detached diagnostic export for JSON, including the\nprimary cause and cleanup error classes. Native stdout/stderr use explicit\nbase64 fields to preserve arbitrary octets. The CLI prints this export on\nstandard error; the library report keeps the original exception objects.\n"
     }
   ]
 }
diff --git a/site/src/data/port-guides/raku.json b/site/src/data/port-guides/raku.json
new file mode 100644
index 000000000..ec533d077
--- /dev/null
+++ b/site/src/data/port-guides/raku.json
@@ -0,0 +1,20 @@
+{
+  "source": {
+    "repository": "libtmux/libtmux-raku",
+    "revision": "8293da87dc45f61ea2a68d1cc5327b4e62892732"
+  },
+  "guides": [
+    {
+      "path": "README.md",
+      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"https://raw.githubusercontent.com/libtmux/libtmux-raku/HEAD/docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"https://raw.githubusercontent.com/libtmux/libtmux-raku/HEAD/docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Raku\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux for Raku\n\n</div>\n\nLibTmux controls tmux from Raku: create sessions and panes, find them through\ntyped snapshots, send input, and react to terminal output. Use ordinary Raku\npredicates and collections alongside validated query data and explicit commands.\n\n## Install\n\nRequires Linux, Raku 6.d and tmux 3.3a through 3.8. Install the published package\nfrom [Raku Land](https://raku.land/zef:libtmux/LibTmux) with its Fez authority:\n\n```console\n$ zef install 'LibTmux:auth<zef:libtmux>'\n```\n\nThe API is experimental and may change between `0.x` releases. CI qualifies\nRakudo 2026.09 on Linux with tmux 3.3a and 3.8; other platforms and compiler\nversions are unverified. See the [changelog][repo-changelog-md] for release history.\nThe [toolchain guide][repo-github-contributing-md-toolchain] covers Raku and zef setup.\nTo install a checkout instead:\n\n```console\n$ zef install .\n```\n\n## Create sessions and panes\n\n### [`Server.start`][api-server-start] and [`PaneRef.split`][api-pane-split]: create and arrange panes\n\nCreate a private tmux session named `work`, split its first pane, and set\nthe pane titles to `editor` and `logs`. Both panes run `cat` as an echo process.\nThis is the complete [quickstart program][repo-examples-quickstart-raku]. `LEAVE`\ncloses the owned server when the program exits, including on an exception.\n\n<!-- runs: examples/quickstart.raku -->\n\n```raku\nuse LibTmux;\n\nmy $server = Server.start(:name<work>, :shell-command('exec cat'));\nLEAVE $server.close if $server.defined;\n\nmy $before = $server.snapshot;\nmy $left = $before.panes.single.ref;\nmy $right = $left.split(:horizontal, :shell-command('exec cat'));\n$left.set-title('editor');\n$right.set-title('logs');\n\nmy $after = $server.snapshot;\nmy $editor = $after.panes.filter(*.title eq 'editor').single;\nsay \"{$editor.title}: {$after.panes.elems} panes\";\n```\n\nIt prints `editor: 2 panes`. The earlier snapshot still contains one\npane: commands through `.ref` change tmux, while snapshots retain the state they\ncaptured. Reading a snapshot or following its relationships makes no further\ntmux calls.\n\nRun it from the checkout with a supported tmux executable on `PATH`:\n\n```console\n$ raku -I. examples/quickstart.raku\n```\n\n## Query captured panes\n\n### [`PaneSelection.where`][api-pane-selection-where]: select panes from a snapshot\n\nCreate panes titled `editor`, `tests`, and `logs`. Select wide panes with query\ndata, then use a Raku predicate to find `editor`. The complete\n[query program][repo-examples-query-panes-raku] also uses native `.grep`, `.map` and\n`.sort` to list the other panes.\n\n<!-- runs: examples/query-panes.raku -->\n\n```raku\nuse v6.d;\nuse LibTmux;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<work>,\n        :width(160), :height(40), :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n\n    my $editor = $server.snapshot.panes.single.ref;\n    my $tests = $editor.split(:horizontal, :shell-command('exec cat'));\n    my $logs = $tests.split(:shell-command('exec cat'));\n    $editor.set-title('editor');\n    $tests.set-title('tests');\n    $logs.set-title('logs');\n\n    my $snapshot = $server.snapshot;\n    my @wide := $snapshot.panes.where(%(width => %(gte => 60)));\n    my $selected = @wide.filter(*.title eq 'editor').single;\n    say \"Wide pane: {$selected.title}\";\n\n    my @others = $snapshot.panes.grep(*.id ne $selected.id).map(*.title).sort;\n    say 'Other panes: ' ~ @others.join(', ');\n}\n```\n\nIt prints `Wide pane: editor` and\n`Other panes: logs, tests`.\n\nBinding with `:=` retains the typed selection. [`where`][api-pane-selection-where]\nvalidates query fields and operators; [`filter`][api-pane-selection-filter]\nreturns another selection of the same entity type.\nNative `.grep` returns a `Seq`, and `.map` can produce ordinary strings.\n`.single` requires exactly one result; `.single-or-nil` permits no result.\nRaku's `.one` keeps its junction meaning.\n\nFor live acquisition, [`query-panes(:where(%criteria))`][api-server-query-panes]\nreturns a fresh selection. [`explain-panes`][api-server-explain-panes] shows\nwhich restrictions run in tmux and which remain local.\nSee the [native query guide][repo-lib-libtmux-rakumod] for\nrelations, portable filters and source execution.\n\n## Adapt to the running daemon\n\n### [`Capabilities.supports`][api-capabilities-supports]: choose a supported operation\n\nCreate an empty `status` pane as a floating pane when supported, with a tiled\nsplit as the fallback. The [capability example][repo-examples-floating-panes-raku]\nasks the captured daemon capabilities before choosing an operation.\n\n<!-- runs: examples/floating-panes.raku -->\n\n```raku\nuse v6.d;\nuse LibTmux;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<work>,\n        :width(120), :height(36), :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n\n    my $snapshot = $server.snapshot;\n    my $main = $snapshot.panes.single.ref;\n    my $floating = $snapshot.capabilities.supports('pane-floating');\n    my $auxiliary = $floating\n        ?? $main.new-floating(:width(40), :height(12), :x(2), :y(2), :empty)\n        !! $main.split(:horizontal, :empty);\n    $auxiliary.set-title('status');\n\n    my $after = $server.snapshot;\n    die 'The auxiliary pane was not captured' unless $after.panes.elems == 2;\n    say 'Status pane: ' ~ ($floating ?? 'floating' !! 'tiled');\n    say $after.panes.where(%(id => $auxiliary.id)).single.title;\n}\n```\n\nIt prints `Status pane: floating` or `Status pane: tiled`,\nfollowed by `status`. A newer client executable does not upgrade an\nolder daemon. Unknown releases are refused conservatively. The\n[compatibility policy][repo-docs-adr-0001-tmux-compatibility-md] describes support;\nthe [field and capability reference][repo-docs-reference-catalogue-rakudoc] lists\nfeature requirements and unavailable values.\n\n## Watch pane output\n\n### [`ControlConnection.events`][api-connection-events]: receive output through a `Supply`\n\nAsynchronous operations return `Promise` values. A control connection exposes\nevents through a shared `Supply`; native `react` and `whenever` consume them.\n[`Server.open-control-async`][api-server-open-control-async] opens the connection.\nThis complete [output watcher][repo-examples-watch-output-raku] subscribes before\nsending text to `cat`, waits for the echoed bytes, then checks the captured screen.\n\n<!-- runs: examples/watch-output.raku -->\n\n```raku\nuse v6.d;\nuse LibTmux;\nuse LibTmux::Control;\n\nsub MAIN(Str:D :$tmux = 'tmux') {\n    my $server = Server.start(:binary($tmux), :name<output>, :shell-command('exec cat'));\n    LEAVE $server.close if $server.defined;\n    my $snapshot = await $server.snapshot-async;\n    my $pane = $snapshot.panes.single.ref;\n    my $connection = await $server.open-control-async(:session-id($snapshot.sessions.single.id));\n    LEAVE $connection.close if $connection.defined;\n\n    my $message = 'hello from Raku';\n    my $received = '';\n    react {\n        whenever $connection.events.grep(PaneOutput) -> $event {\n            if $event.pane-id eq $pane.id {\n                $received ~= $event.data.decode('utf8-c8');\n                die 'Pane output exceeded its bound' if $received.chars > 65536;\n                done if $received.contains($message);\n            }\n        }\n        whenever start { $pane.send-text($message); $pane.send-keys('Enter') } { }\n        whenever Promise.in(2) { die 'Pane output timed out' }\n    }\n\n    die 'The captured screen did not contain the message'\n        unless $pane.capture.decode('utf8').contains($message);\n    say $message;\n    say 'Screen capture confirmed';\n}\n```\n\nIt prints `hello from Raku` and `Screen capture confirmed`.\nThe deadline bounds the wait; output events supply the completion evidence.\n`send-text` sends literal text, and `send-keys('Enter')` submits it separately.\nPane output arrives as bytes so fragmented or invalid UTF-8 remains available.\n\nThe longer [session workflow program][repo-examples-session-workflow-raku] combines pane\ncreation, output observation, capture, local queries and an explained source\nquery in one lifecycle.\n\n## Recover after a batch fails\n\n### [`Server.run-batch`][api-server-run-batch]: inspect partial completion\n\nA batch records each operation's outcome. The\n[recovery program][repo-examples-batch-recovery-raku] produces `Complete`, `Failed`\nand `Skipped`, verifies that the first effect remains, then removes that effect\nexplicitly. Command acknowledgement alone does not establish application\ncompletion, and a failed batch does not roll back earlier commands.\n\n```console\n$ raku -I. examples/batch-recovery.raku\n```\n\nThe [examples guide][repo-examples-readme-md] gives the commands, expected results and\ncleanup behavior for every complete program.\n\n## Ownership and documentation\n\n### [`Server.close`][api-server-close]: close an owned daemon\n\n[`Server.start`][api-server-start] creates and owns a daemon on a private socket.\n[`Server.new`][api-server-new] configures a borrowed endpoint; closing it leaves\nthat daemon running. Close both explicitly. Control connections and terminal\nattachments have their own lifetimes and also need closing. References are\nscoped to the observed daemon incarnation and refuse a replacement daemon.\n\nAPI links open the native declarations and their RakuDoc comments.\n\n- [Native API guide][repo-lib-libtmux-rakumod]: the object graph, queries,\n  capabilities, async execution, control events and recovery.\n- [Examples][repo-examples-readme-md]: complete Raku programs with checked results.\n- [Contributing][repo-github-contributing-md]: compiler setup and validation.\n- [API documentation authoring][repo-docs-documentation-rakudoc] and\n  [writing conventions][repo-github-writing-md].\n- [MIT license][repo-license] and [artwork provenance][repo-docs-assets-readme-md].\n\n[api-capabilities-supports]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Capabilities.rakumod#L126\n[api-connection-events]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Control/Connection.rakumod#L147\n[api-pane-selection-filter]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Selection.rakumod#L68\n[api-pane-selection-where]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Selection.rakumod#L78\n[api-pane-split]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Model.rakumod#L279\n[api-server-close]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L685\n[api-server-explain-panes]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L432\n[api-server-new]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L290\n[api-server-open-control-async]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L579\n[api-server-query-panes]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L430\n[api-server-run-batch]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L608\n[api-server-start]: https://github.com/libtmux/libtmux-raku/blob/f543ca5de32e04445f4d6e29c66e5dba94ac9a63/lib/LibTmux/Server.rakumod#L622\n[repo-changelog-md]: https://github.com/libtmux/libtmux-raku/blob/master/CHANGELOG.md\n[repo-docs-adr-0001-tmux-compatibility-md]: https://github.com/libtmux/libtmux-raku/blob/master/docs/adr/0001-tmux-compatibility.md\n[repo-docs-assets-readme-md]: https://github.com/libtmux/libtmux-raku/blob/master/docs/assets/README.md\n[repo-docs-documentation-rakudoc]: https://github.com/libtmux/libtmux-raku/blob/master/docs/documentation.rakudoc\n[repo-docs-reference-catalogue-rakudoc]: https://github.com/libtmux/libtmux-raku/blob/master/docs/reference/catalogue.rakudoc\n[repo-examples-batch-recovery-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/batch-recovery.raku\n[repo-examples-floating-panes-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/floating-panes.raku\n[repo-examples-query-panes-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/query-panes.raku\n[repo-examples-quickstart-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/quickstart.raku\n[repo-examples-readme-md]: https://github.com/libtmux/libtmux-raku/blob/master/examples/README.md\n[repo-examples-session-workflow-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/session-workflow.raku\n[repo-examples-watch-output-raku]: https://github.com/libtmux/libtmux-raku/blob/master/examples/watch-output.raku\n[repo-github-contributing-md]: https://github.com/libtmux/libtmux-raku/blob/master/.github/CONTRIBUTING.md\n[repo-github-contributing-md-toolchain]: https://github.com/libtmux/libtmux-raku/blob/master/.github/CONTRIBUTING.md#toolchain\n[repo-github-writing-md]: https://github.com/libtmux/libtmux-raku/blob/master/.github/WRITING.md\n[repo-lib-libtmux-rakumod]: https://github.com/libtmux/libtmux-raku/blob/master/lib/LibTmux.rakumod\n[repo-license]: https://github.com/libtmux/libtmux-raku/blob/master/LICENSE\n"
+    },
+    {
+      "path": "examples/README.md",
+      "content": "<!-- libtmux-logo -->\n<div align=\"center\">\n  <picture>\n    <source srcset=\"../docs/assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"../docs/assets/logo-512.png\" width=\"128\" height=\"128\" alt=\"libtmux for Raku\">\n  </picture>\n</div>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux Raku examples\n\n</div>\n\nCreate sessions, split panes, watch terminal output, and recover a failed command.\nThese complete Raku programs use [LibTmux](../README.md) to own private tmux\nservers. Each closes its clients and daemon when it exits.\n\nRun commands from the repository root after the\n[toolchain setup](../.github/CONTRIBUTING.md#toolchain), with a supported tmux\nexecutable on `PATH`:\n\n```console\n$ zef install .\n```\n\n| Task | Program | Raku facilities |\n| --- | --- | --- |\n| Create and find panes | [Quickstart](quickstart.raku) | Objects, `LEAVE`, a native predicate |\n| Select wide panes | [Pane queries](query-panes.raku) | Typed selections, query hashes, `grep`, `map`, `sort` |\n| Add a status pane | [Floating panes](floating-panes.raku) | Capability checks and a tiled fallback |\n| Watch pane output | [Watch output](watch-output.raku) | `Promise`, `Supply`, `react`, `whenever` |\n| Combine the workflow | [Session workflow](session-workflow.raku) | Events, captured graphs and query plans |\n| Recover after a command fails | [Batch recovery](batch-recovery.raku) | Typed outcomes and explicit recovery |\n\n## Create and find panes\n\nThe [quickstart](quickstart.raku) is the complete first program in the root\nREADME. It creates two panes, sets their titles, and finds the editor pane through\na fresh snapshot. The earlier snapshot retains one pane.\n\n```console\n$ raku -I. examples/quickstart.raku\n```\n\nIt prints `editor: 2 panes`.\n\n## Select wide panes\n\nThe [pane query program](query-panes.raku) creates panes titled `editor`,\n`tests`, and `logs`. `.where` selects the wide panes, `.filter` finds\n`editor`, and `.single` checks cardinality. Native `.grep`, `.map` and `.sort`\nproduce the remaining pane names as ordinary Raku values.\n\n```console\n$ raku -I. examples/query-panes.raku\n```\n\nIt prints `Wide pane: editor` and\n`Other panes: logs, tests`.\n\nUse `:=` when binding a typed selection to an array variable. Assignment with\n`=` materializes ordinary array membership. Repeated traversal reads the\ncaptured members; it does not refresh tmux.\n\n## Add a status pane\n\nThe [floating-pane program](floating-panes.raku) creates an empty `status`\npane. It checks the daemon's `pane-floating` capability, chooses a floating pane\nwhen available, and otherwise splits the tiled window.\n\n```console\n$ raku -I. examples/floating-panes.raku\n```\n\nIt prints the selected placement, then `status`. The empty display\nhas no child process on profiles that report an absent PID; the pane still\nbelongs to the captured graph. Consult capabilities before offering an\noperation to a user.\n\n## Watch pane output\n\nThe [output watcher](watch-output.raku) awaits asynchronous snapshot and control\nconnection operations, subscribes to pane-output events, and sends text to\n`cat` as an echo process.\n`react` and `whenever` collect fragmented bytes until the complete message\narrives. It then checks the captured screen.\n\n```console\n$ raku -I. examples/watch-output.raku\n```\n\nIt prints `hello from Raku` and `Screen capture confirmed`.\nThe deadline bounds the wait. Multiple event subscribers share the same owned\nconnection. Sending text and pressing Enter are separate operations.\n\n## Run the complete session workflow\n\nThe [session workflow](session-workflow.raku) combines pane creation, literal input,\ncontrol-mode observation and screen capture. It filters a snapshot with query\ndata and a Raku predicate, then compares an exact source query with the captured\npane. Its query plan shows where evaluation takes place.\n\n```console\n$ raku -I. examples/session-workflow.raku\n```\n\nThe output includes `Session: 2 panes`,\n`editor: hello from Raku`, and\n`Owned clients, daemon and socket cleaned up`.\n\n## Recover after a command fails\n\nThe [batch recovery example](batch-recovery.raku) sets an option, sends an\ninvalid command, and checks that the following command was skipped. It verifies\nthe first effect and removes it explicitly.\n\n```console\n$ raku -I. examples/batch-recovery.raku\n```\n\nIt reports `Complete`, `Failed` and `Skipped` outcomes, followed by\n`Recovery: removed the first effect explicitly` and\n`Owned daemon and socket cleaned up`. A failed batch does not undo commands\nthat already succeeded.\n\n## Select a tmux executable\n\nEvery program except the minimal quickstart accepts `--tmux`. For that\nquickstart, select the supported binary through `PATH`. The repository's\n[example check](../tools/check-examples.raku) selects `LIBTMUX_TEST_TMUX` through\na private temporary `PATH`, checks displayed source against these files, runs\nall programs, checks their results, and rejects leftover owned socket\ndirectories. See [Contributing](../.github/CONTRIBUTING.md#checks) for validation.\n"
+    },
+    {
+      "path": "docs/adr/0001-tmux-compatibility.md",
+      "content": "# tmux compatibility\n\nStatus: accepted.\n\n## Decision\n\nSupport Linux and the declared stable tmux releases from 3.3a through 3.8.\nUse the daemon's version and observed capabilities when selecting commands,\nfields, codecs and layouts. A newer client executable does not upgrade the\ndaemon. Unknown and vendor releases require an explicit support decision.\n\nKeep release profiles in [LibTmux::Catalogue](../../lib/LibTmux/Catalogue.rakumod).\nEach profile names its upstream commit. The oldest and newest profiles define\nthe required live CI jobs; intermediate releases retain pure compatibility\nfixtures. Feature boundaries and known defects belong in the field catalogue.\n\n## Rationale\n\nRuntime checks and CI must agree on supported releases. Typed release records\nprovide one source for both without a separate configuration format. CI verifies\nthe fetched tag against the pinned commit; it does not need a second inventory\nof individual source-file hashes.\n\nAdding a supported release requires reviewing its feature and defect policies,\nupdating its profile, and passing the relevant fixtures and endpoint tests.\n"
+    }
+  ]
+}
diff --git a/site/src/data/registry.json b/site/src/data/registry.json
index b5b4e9fcb..64a67420d 100644
--- a/site/src/data/registry.json
+++ b/site/src/data/registry.json
@@ -30,41 +30,41 @@
     },
     "ruby": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0",
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "v0.1.2",
       "packages": {
         "libtmux": {
           "status": "release",
-          "version": "0.1.0",
-          "release": "0.1.0",
-          "tag": "v0.1.0"
+          "version": "0.1.2",
+          "release": "0.1.2",
+          "tag": "v0.1.2"
         },
         "libtmux-async": {
           "status": "release",
-          "version": "0.1.0",
-          "release": "0.1.0",
-          "tag": "v0.1.0"
+          "version": "0.1.2",
+          "release": "0.1.2",
+          "tag": "v0.1.2"
         },
         "libtmux-mcp": {
           "status": "release",
-          "version": "0.1.0",
-          "release": "0.1.0",
-          "tag": "v0.1.0"
+          "version": "0.1.2",
+          "release": "0.1.2",
+          "tag": "v0.1.2"
         },
         "libtmux-workspace": {
           "status": "release",
-          "version": "0.1.0",
-          "release": "0.1.0",
-          "tag": "v0.1.0"
+          "version": "0.1.2",
+          "release": "0.1.2",
+          "tag": "v0.1.2"
         }
       }
     },
     "lua": {
       "status": "release",
-      "version": "0.1.0-1",
-      "release": "0.1.0-1",
-      "tag": "v0.1.0"
+      "version": "0.1.1-1",
+      "release": "0.1.1-1",
+      "tag": "v0.1.1"
     },
     "powershell": {
       "status": "release",
@@ -90,106 +90,109 @@
       "status": "unpublished",
       "version": null,
       "release": null,
-      "tag": "v0.1.1-alpha.2"
+      "tag": "v0.1.1",
+      "maturity": "unreleased"
     },
     "erlang": {
-      "status": "unpublished",
-      "version": null,
-      "release": null,
-      "tag": null,
+      "status": "release",
+      "version": "0.0.1",
+      "release": "0.0.1",
+      "tag": "v0.0.1",
       "packages": {
         "libtmux_erlang": {
-          "status": "unpublished",
-          "version": null,
-          "release": null,
-          "tag": null
+          "status": "release",
+          "version": "0.0.1",
+          "release": "0.0.1",
+          "tag": "v0.0.1"
         }
       }
     },
     "elixir": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.1",
+      "release": "0.1.1",
+      "tag": "v0.1.1"
     },
     "haskell": {
       "status": "unpublished",
       "version": null,
       "release": null,
-      "tag": null
+      "tag": null,
+      "maturity": "unreleased"
     },
     "lisp": {
       "status": "unpublished",
       "version": null,
       "release": null,
-      "tag": null
+      "tag": null,
+      "maturity": "unreleased"
     },
     "ts": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "v0.1.2"
     },
     "rs": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "libtmux@v0.1.0"
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "libtmux@v0.1.2"
     },
     "go": {
       "status": "release",
-      "version": "v0.1.0",
-      "release": "v0.1.0",
-      "tag": "v0.1.0"
+      "version": "v0.1.3",
+      "release": "v0.1.3",
+      "tag": "v0.1.3"
     },
     "java": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "v0.1.2"
     },
     "clojure": {
       "status": "unpublished",
       "version": null,
       "release": null,
-      "tag": null,
+      "tag": "v0.1.2",
       "maturity": "unreleased"
     },
     "kotlin": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "v0.1.2"
     },
     "scala": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.2",
+      "release": "0.1.2",
+      "tag": "v0.1.2"
     },
     "csharp": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.1",
+      "release": "0.1.1",
+      "tag": "v0.1.1"
     },
     "fsharp": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "v0.1.0"
+      "version": "0.1.1",
+      "release": "0.1.1",
+      "tag": "v0.1.1"
     },
     "cxx": {
       "status": "unpublished",
       "version": null,
       "release": null,
-      "tag": "v0.1.0-alpha.13"
+      "tag": "v0.1.0"
     },
     "swift": {
       "status": "release",
-      "version": "0.1.0",
-      "release": "0.1.0",
-      "tag": "0.1.0"
+      "version": "0.1.1",
+      "release": "0.1.1",
+      "tag": "0.1.1"
     },
     "ocaml": {
       "status": "unpublished",
@@ -199,34 +202,36 @@
       "maturity": "unreleased"
     },
     "perl": {
-      "status": "unpublished",
-      "version": null,
-      "release": null,
-      "tag": null,
-      "maturity": "unreleased",
+      "status": "release",
+      "version": "0.003",
+      "release": "0.003",
+      "tag": "v0.003",
       "packages": {
         "LibTmux": {
-          "status": "unpublished",
-          "version": null,
-          "release": null,
-          "tag": null,
-          "maturity": "unreleased"
+          "status": "release",
+          "version": "0.003",
+          "release": "0.003",
+          "tag": "v0.003"
         },
         "LibTmux-Async": {
-          "status": "unpublished",
-          "version": null,
-          "release": null,
-          "tag": null,
-          "maturity": "unreleased"
+          "status": "release",
+          "version": "0.003",
+          "release": "0.003",
+          "tag": "v0.003"
         },
         "LibTmux-Workspace": {
-          "status": "unpublished",
-          "version": null,
-          "release": null,
-          "tag": null,
-          "maturity": "unreleased"
+          "status": "release",
+          "version": "0.003",
+          "release": "0.003",
+          "tag": "v0.003"
         }
       }
+    },
+    "raku": {
+      "status": "release",
+      "version": "0.0.1",
+      "release": "0.0.1",
+      "tag": "v0.0.1"
     }
   }
 }
diff --git a/site/src/data/tmux-usage/erlang.json b/site/src/data/tmux-usage/erlang.json
index a28b84f27..d6e9cbbf3 100644
--- a/site/src/data/tmux-usage/erlang.json
+++ b/site/src/data/tmux-usage/erlang.json
@@ -94,7 +94,7 @@
   ],
   "port": "erlang",
   "repo": "libtmux/libtmux-erlang",
-  "revision": "f1a2e66c0fa15d1e8d4efa2725a159121815293b",
+  "revision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64",
   "schemaVersion": 1,
   "symbols": {
     "tmux_buffer:delete/2": [
diff --git a/site/src/data/tmux-usage/perl.json b/site/src/data/tmux-usage/perl.json
index aa4609bb0..31abde47e 100644
--- a/site/src/data/tmux-usage/perl.json
+++ b/site/src/data/tmux-usage/perl.json
@@ -94,7 +94,7 @@
   ],
   "port": "perl",
   "repo": "libtmux/libtmux-perl",
-  "revision": "d9fa7c5278d243c671a29cdb00e3a911ac651bfa",
+  "revision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
   "schemaVersion": 1,
   "symbols": {
     "LibTmux::Async::Server::capture_pane": [
diff --git a/site/src/data/tmux-usage/raku.json b/site/src/data/tmux-usage/raku.json
new file mode 100644
index 000000000..d68d322c8
--- /dev/null
+++ b/site/src/data/tmux-usage/raku.json
@@ -0,0 +1,3113 @@
+{
+  "commands": [
+    "attach-session",
+    "bind-key",
+    "break-pane",
+    "capture-pane",
+    "choose-buffer",
+    "choose-client",
+    "choose-tree",
+    "clear-history",
+    "clear-prompt-history",
+    "clock-mode",
+    "command-prompt",
+    "confirm-before",
+    "copy-mode",
+    "customize-mode",
+    "delete-buffer",
+    "detach-client",
+    "display-menu",
+    "display-message",
+    "display-panes",
+    "display-popup",
+    "find-window",
+    "has-session",
+    "if-shell",
+    "join-pane",
+    "kill-pane",
+    "kill-server",
+    "kill-session",
+    "kill-window",
+    "last-pane",
+    "last-window",
+    "link-window",
+    "list-buffers",
+    "list-clients",
+    "list-commands",
+    "list-keys",
+    "list-panes",
+    "list-sessions",
+    "list-windows",
+    "load-buffer",
+    "lock-client",
+    "lock-server",
+    "lock-session",
+    "move-pane",
+    "move-window",
+    "new-pane",
+    "new-session",
+    "new-window",
+    "next-layout",
+    "next-window",
+    "paste-buffer",
+    "pipe-pane",
+    "previous-layout",
+    "previous-window",
+    "refresh-client",
+    "rename-session",
+    "rename-window",
+    "resize-pane",
+    "resize-window",
+    "respawn-pane",
+    "respawn-window",
+    "rotate-window",
+    "run-shell",
+    "save-buffer",
+    "select-layout",
+    "select-pane",
+    "select-window",
+    "send-keys",
+    "send-prefix",
+    "server-access",
+    "set-buffer",
+    "set-environment",
+    "set-hook",
+    "set-option",
+    "set-window-option",
+    "show-buffer",
+    "show-environment",
+    "show-hooks",
+    "show-messages",
+    "show-options",
+    "show-prompt-history",
+    "show-window-options",
+    "source-file",
+    "split-window",
+    "start-server",
+    "suspend-client",
+    "swap-pane",
+    "swap-window",
+    "switch-client",
+    "unbind-key",
+    "unlink-window",
+    "wait-for"
+  ],
+  "port": "raku",
+  "repo": "libtmux/libtmux-raku",
+  "revision": "8293da87dc45f61ea2a68d1cc5327b4e62892732",
+  "schemaVersion": 1,
+  "symbols": {
+    "LibTmux::Attachment.inspect-client": [
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Attachment.rakumod:202",
+          "lib/LibTmux/Attachment.rakumod:197"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "the child has not exited"
+      }
+    ],
+    "LibTmux::Attachment.spawn": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Attachment.rakumod:86",
+          "lib/LibTmux/Attachment.rakumod:74",
+          "lib/LibTmux/Attachment.rakumod:112"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Attachment.rakumod:70"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.choose": [
+      {
+        "command": "choose-buffer",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:251"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is buffer"
+      },
+      {
+        "command": "choose-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is client"
+      },
+      {
+        "command": "choose-tree",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is tree"
+      },
+      {
+        "command": "customize-mode",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:251"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is customize"
+      }
+    ],
+    "LibTmux::Client::ClientTarget.clear-prompt-history": [
+      {
+        "command": "clear-prompt-history",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:369",
+          "lib/LibTmux/Client.rakumod:367"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.close-popup": [
+      {
+        "command": "display-popup",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:213"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.confirm-async": [
+      {
+        "command": "confirm-before",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:239"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.detach": [
+      {
+        "command": "detach-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:314"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.display-format": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:151",
+          "lib/LibTmux/Client.rakumod:148"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.display-message": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:142",
+          "lib/LibTmux/Client.rakumod:138"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.display-panes-async": [
+      {
+        "command": "display-panes",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:295",
+          "lib/LibTmux/Client.rakumod:291"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.find-window": [
+      {
+        "command": "find-window",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:283",
+          "lib/LibTmux/Client.rakumod:275"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.key-table": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:339"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.lock": [
+      {
+        "command": "lock-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:324"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.menu-async": [
+      {
+        "command": "display-menu",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:184",
+          "lib/LibTmux/Client.rakumod:163"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.popup-async": [
+      {
+        "command": "display-popup",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:208",
+          "lib/LibTmux/Client.rakumod:197"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.prompt-async": [
+      {
+        "command": "command-prompt",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:233",
+          "lib/LibTmux/Client.rakumod:225"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.prompt-history": [
+      {
+        "command": "show-prompt-history",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:362",
+          "lib/LibTmux/Client.rakumod:360"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.refresh": [
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:309",
+          "lib/LibTmux/Client.rakumod:306"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.suspend": [
+      {
+        "command": "suspend-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:319"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.switch": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:333",
+          "lib/LibTmux/Client.rakumod:330"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.switch-relative": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:348"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Client::ClientTarget.toggle-read-only": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:354"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.delete": [
+      {
+        "command": "delete-buffer",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:450"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.get": [
+      {
+        "command": "save-buffer",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:440"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.list": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:429"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.paste": [
+      {
+        "command": "paste-buffer",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:465",
+          "lib/LibTmux/Configuration.rakumod:461"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.put": [
+      {
+        "command": "load-buffer",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:445"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Buffers.rename": [
+      {
+        "command": "set-buffer",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:455"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Environment.get": [
+      {
+        "command": "show-environment",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:379",
+          "lib/LibTmux/Configuration.rakumod:376"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Environment.list": [
+      {
+        "command": "show-environment",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:361",
+          "lib/LibTmux/Configuration.rakumod:359"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Environment.remove": [
+      {
+        "command": "set-environment",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:402"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Environment.set": [
+      {
+        "command": "set-environment",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:392",
+          "lib/LibTmux/Configuration.rakumod:389"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Environment.unset": [
+      {
+        "command": "set-environment",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:397"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Hooks.append": [
+      {
+        "command": "set-hook",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:501"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Hooks.list": [
+      {
+        "command": "show-hooks",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:488",
+          "lib/LibTmux/Configuration.rakumod:486"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Hooks.run": [
+      {
+        "command": "set-hook",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:512"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Hooks.set": [
+      {
+        "command": "set-hook",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:496"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Hooks.unset": [
+      {
+        "command": "set-hook",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:506"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::KeyBindings.bind": [
+      {
+        "command": "bind-key",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:551",
+          "lib/LibTmux/Configuration.rakumod:547"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::KeyBindings.clear": [
+      {
+        "command": "unbind-key",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:561"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::KeyBindings.list": [
+      {
+        "command": "list-keys",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:570",
+          "lib/LibTmux/Configuration.rakumod:578"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::KeyBindings.unbind": [
+      {
+        "command": "unbind-key",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:556"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.entries": [
+      {
+        "command": "show-options",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:196",
+          "lib/LibTmux/Configuration.rakumod:193"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.get": [
+      {
+        "command": "show-options",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:206",
+          "lib/LibTmux/Configuration.rakumod:193",
+          "lib/LibTmux/Configuration.rakumod:196"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.get-raw": [
+      {
+        "command": "show-options",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:261"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.set": [
+      {
+        "command": "set-option",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:243"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.set-raw": [
+      {
+        "command": "set-option",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:256"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Configuration::Options.unset": [
+      {
+        "command": "set-option",
+        "evidence": [
+          "lib/LibTmux/Configuration.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Control::Connection.connect": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:160",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:229",
+          "lib/LibTmux/Control/Connection.rakumod:230"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:160",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:202",
+          "lib/LibTmux/Control/Connection.rakumod:203"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "new-layouts negotiation is enabled"
+      }
+    ],
+    "LibTmux::Control::Connection.connect-async": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:229",
+          "lib/LibTmux/Control/Connection.rakumod:230"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:202",
+          "lib/LibTmux/Control/Connection.rakumod:203"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "new-layouts negotiation is enabled"
+      }
+    ],
+    "LibTmux::Control::Connection.observe": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:463",
+          "lib/LibTmux/Control/Connection.rakumod:471",
+          "lib/LibTmux/Control/Connection.rakumod:365"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Control::Connection.observe-async": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:471",
+          "lib/LibTmux/Control/Connection.rakumod:365"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Control::Connection.query": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "buffer query or full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "client query or full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "pane query or full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "session/group query or full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "window/link query or full graph"
+      }
+    ],
+    "LibTmux::Control::Connection.query-async": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "buffer query or full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "client query or full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "pane query or full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "session/group query or full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "window/link query or full graph"
+      }
+    ],
+    "LibTmux::Control::Connection.query-panes": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:511",
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:511",
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:511",
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:511",
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:511",
+          "lib/LibTmux/Control/Connection.rakumod:491",
+          "lib/LibTmux/Control/Connection.rakumod:507",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      }
+    ],
+    "LibTmux::Control::Connection.snapshot": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:477",
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:477",
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:477",
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:477",
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:477",
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Control::Connection.snapshot-async": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Control/Connection.rakumod:481",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::ClientRef.choose": [
+      {
+        "command": "choose-buffer",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:251"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is buffer"
+      },
+      {
+        "command": "choose-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is client"
+      },
+      {
+        "command": "choose-tree",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is tree"
+      },
+      {
+        "command": "customize-mode",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:265",
+          "lib/LibTmux/Client.rakumod:251"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "kind is customize"
+      }
+    ],
+    "LibTmux::Model::ClientRef.clear-prompt-history": [
+      {
+        "command": "clear-prompt-history",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:369",
+          "lib/LibTmux/Client.rakumod:367"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.close-popup": [
+      {
+        "command": "display-popup",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:213"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.confirm-async": [
+      {
+        "command": "confirm-before",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:239"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.detach": [
+      {
+        "command": "detach-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:314"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.display-format": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:151",
+          "lib/LibTmux/Client.rakumod:148"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.display-message": [
+      {
+        "command": "display-message",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:142",
+          "lib/LibTmux/Client.rakumod:138"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.display-panes-async": [
+      {
+        "command": "display-panes",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:295",
+          "lib/LibTmux/Client.rakumod:291"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.find-window": [
+      {
+        "command": "find-window",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:283",
+          "lib/LibTmux/Client.rakumod:275"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.inspect": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:577",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:577",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:577",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:577",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:577",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::ClientRef.key-table": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:339"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.lock": [
+      {
+        "command": "lock-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:324"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.menu-async": [
+      {
+        "command": "display-menu",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:184",
+          "lib/LibTmux/Client.rakumod:163"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.popup-async": [
+      {
+        "command": "display-popup",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:208",
+          "lib/LibTmux/Client.rakumod:197"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.prompt-async": [
+      {
+        "command": "command-prompt",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:233",
+          "lib/LibTmux/Client.rakumod:225"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.prompt-history": [
+      {
+        "command": "show-prompt-history",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:362",
+          "lib/LibTmux/Client.rakumod:360"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.refresh": [
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:309",
+          "lib/LibTmux/Client.rakumod:306"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.suspend": [
+      {
+        "command": "suspend-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:319"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.switch": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:333",
+          "lib/LibTmux/Client.rakumod:330"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.switch-relative": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:348"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::ClientRef.toggle-read-only": [
+      {
+        "command": "switch-client",
+        "evidence": [
+          "lib/LibTmux/Client.rakumod:354"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.break": [
+      {
+        "command": "break-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:447",
+          "lib/LibTmux/Model.rakumod:417"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:427"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:434"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::PaneRef.capture": [
+      {
+        "command": "capture-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:271",
+          "lib/LibTmux/Model.rakumod:262"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.capture-pending": [
+      {
+        "command": "capture-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:275"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.clear-history": [
+      {
+        "command": "clear-history",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:465"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.clock-mode": [
+      {
+        "command": "clock-mode",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:485"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.copy-command": [
+      {
+        "command": "send-keys",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:482"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.copy-mode": [
+      {
+        "command": "copy-mode",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:477"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.float": [
+      {
+        "command": "break-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:394"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.inspect": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::PaneRef.join": [
+      {
+        "command": "join-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:357",
+          "lib/LibTmux/Model.rakumod:348"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.kill": [
+      {
+        "command": "kill-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:495"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.move": [
+      {
+        "command": "move-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:363",
+          "lib/LibTmux/Model.rakumod:348"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.move-floating": [
+      {
+        "command": "move-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:369"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.new-floating": [
+      {
+        "command": "new-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:312",
+          "lib/LibTmux/Model.rakumod:305"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.pipe": [
+      {
+        "command": "pipe-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:490"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.reset": [
+      {
+        "command": "clear-history",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:472",
+          "lib/LibTmux/Model.rakumod:471"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "if-shell",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:472"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "send-keys",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:472",
+          "lib/LibTmux/Model.rakumod:470"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.reset-terminal": [
+      {
+        "command": "send-keys",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:467"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.resize": [
+      {
+        "command": "resize-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:317"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.respawn": [
+      {
+        "command": "respawn-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:341"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.select": [
+      {
+        "command": "select-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:324"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.send-keys": [
+      {
+        "command": "send-keys",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:250"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.send-prefix": [
+      {
+        "command": "send-prefix",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:254"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.send-text": [
+      {
+        "command": "send-keys",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:245"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.set-input": [
+      {
+        "command": "select-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:332"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.set-title": [
+      {
+        "command": "select-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:328"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.set-z-index": [
+      {
+        "command": "move-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:382"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.split": [
+      {
+        "command": "split-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:294",
+          "lib/LibTmux/Model.rakumod:287"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.stack": [
+      {
+        "command": "move-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:377"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.swap": [
+      {
+        "command": "swap-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:402"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.tile": [
+      {
+        "command": "move-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:387"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.toggle-mark": [
+      {
+        "command": "select-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:335"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.toggle-zoom": [
+      {
+        "command": "resize-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:321"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::PaneRef.unmark": [
+      {
+        "command": "select-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:337"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.detach-clients": [
+      {
+        "command": "detach-client",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:167"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.inspect": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::SessionRef.kill": [
+      {
+        "command": "kill-session",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:169"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.last-window": [
+      {
+        "command": "last-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:161"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.lock": [
+      {
+        "command": "lock-session",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:165"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.new-window": [
+      {
+        "command": "new-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:149",
+          "lib/LibTmux/Model.rakumod:142"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.next-window": [
+      {
+        "command": "next-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:154"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.previous-window": [
+      {
+        "command": "previous-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:158"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.rename": [
+      {
+        "command": "rename-session",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:132"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::SessionRef.renumber-windows": [
+      {
+        "command": "move-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:163"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowLinkRef.move": [
+      {
+        "command": "move-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:549"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowLinkRef.select": [
+      {
+        "command": "select-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:533"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowLinkRef.swap": [
+      {
+        "command": "swap-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:561"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowLinkRef.unlink": [
+      {
+        "command": "unlink-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:540"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.inspect": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:107",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::WindowRef.kill": [
+      {
+        "command": "kill-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:239"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.last-pane": [
+      {
+        "command": "last-pane",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:206"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.link": [
+      {
+        "command": "link-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:232"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:227"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Model::WindowRef.next-layout": [
+      {
+        "command": "next-layout",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:200"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.previous-layout": [
+      {
+        "command": "previous-layout",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:202"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.rename": [
+      {
+        "command": "rename-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:176"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.resize": [
+      {
+        "command": "resize-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:180"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.respawn": [
+      {
+        "command": "respawn-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:215"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.restore-layout": [
+      {
+        "command": "select-layout",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:197"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.rotate": [
+      {
+        "command": "rotate-window",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:209"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.select-layout": [
+      {
+        "command": "select-layout",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:190"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Model::WindowRef.spread-layout": [
+      {
+        "command": "select-layout",
+        "evidence": [
+          "lib/LibTmux/Model.rakumod:204"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.attach": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:592",
+          "lib/LibTmux/Server.rakumod:602",
+          "lib/LibTmux/Attachment.rakumod:86",
+          "lib/LibTmux/Attachment.rakumod:74",
+          "lib/LibTmux/Attachment.rakumod:112"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.attach-async": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:602",
+          "lib/LibTmux/Attachment.rakumod:86",
+          "lib/LibTmux/Attachment.rakumod:74",
+          "lib/LibTmux/Attachment.rakumod:112"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.buffers": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:562",
+          "lib/LibTmux/Server.rakumod:544",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.capabilities": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:384",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.capabilities-async": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:388",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.environment": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:558",
+          "lib/LibTmux/Server.rakumod:544",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.explain": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:398",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.explain-panes": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:432",
+          "lib/LibTmux/Server.rakumod:398",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.from-env": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:324",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.has-session": [
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:449",
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.hooks": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:567",
+          "lib/LibTmux/Server.rakumod:544",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.if-shell": [
+      {
+        "command": "if-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:498",
+          "lib/LibTmux/Server.rakumod:504"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.key-bindings": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:571",
+          "lib/LibTmux/Server.rakumod:544",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.kill-server": [
+      {
+        "command": "kill-server",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:539"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.new-session": [
+      {
+        "command": "new-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:455",
+          "lib/LibTmux/Server.rakumod:453",
+          "lib/LibTmux/Server.rakumod:65",
+          "lib/LibTmux/Server.rakumod:72"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.open-control": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:576",
+          "lib/LibTmux/Server.rakumod:583",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:229",
+          "lib/LibTmux/Control/Connection.rakumod:230"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:576",
+          "lib/LibTmux/Server.rakumod:583",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:202",
+          "lib/LibTmux/Control/Connection.rakumod:203"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "new-layouts negotiation is enabled"
+      }
+    ],
+    "LibTmux::Server.open-control-async": [
+      {
+        "command": "attach-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:583",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:229",
+          "lib/LibTmux/Control/Connection.rakumod:230"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "refresh-client",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:583",
+          "lib/LibTmux/Control/Connection.rakumod:200",
+          "lib/LibTmux/Control/Connection.rakumod:202",
+          "lib/LibTmux/Control/Connection.rakumod:203"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "new-layouts negotiation is enabled"
+      }
+    ],
+    "LibTmux::Server.options": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:554",
+          "lib/LibTmux/Server.rakumod:544",
+          "lib/LibTmux/Server.rakumod:368",
+          "lib/LibTmux/Engine.rakumod:283",
+          "lib/LibTmux/Engine.rakumod:247",
+          "lib/LibTmux/Engine.rakumod:245"
+        ],
+        "incidental": true,
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.query": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "buffer query or full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "client query or full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "pane query or full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "session/group query or full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "window/link query or full graph"
+      }
+    ],
+    "LibTmux::Server.query-async": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "buffer query or full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "client query or full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "pane query or full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "session/group query or full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "window/link query or full graph"
+      }
+    ],
+    "LibTmux::Server.query-panes": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:430",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:430",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:430",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:430",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:430",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      }
+    ],
+    "LibTmux::Server.query-sessions": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:434",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      }
+    ],
+    "LibTmux::Server.query-window-links": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:438",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:438",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:438",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:438",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:438",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Server.query-windows": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:436",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:436",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:218",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:436",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server",
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:436",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:216",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null,
+        "when": "relationship predicates require a full graph"
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:436",
+          "lib/LibTmux/Server.rakumod:405",
+          "lib/LibTmux/Server.rakumod:426",
+          "lib/LibTmux/Query/Execution.rakumod:36",
+          "lib/LibTmux/Query/Execution.rakumod:37",
+          "lib/LibTmux/Query/Execution.rakumod:39",
+          "lib/LibTmux/Query/Plan.rakumod:217",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Server.run-shell": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:483",
+          "lib/LibTmux/Server.rakumod:487",
+          "lib/LibTmux/Server.rakumod:489",
+          "lib/LibTmux/Server.rakumod:478"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.run-shell-async": [
+      {
+        "command": "run-shell",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:487",
+          "lib/LibTmux/Server.rakumod:489"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.snapshot": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:375",
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:375",
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:375",
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:375",
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:375",
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Server.snapshot-async": [
+      {
+        "command": "list-buffers",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-clients",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:993"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-panes",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      },
+      {
+        "command": "list-sessions",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:991"
+        ],
+        "reviewed": true,
+        "scope": null
+      },
+      {
+        "command": "list-windows",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:379",
+          "lib/LibTmux/Model.rakumod:1004",
+          "lib/LibTmux/Model.rakumod:992"
+        ],
+        "reviewed": true,
+        "scope": "server"
+      }
+    ],
+    "LibTmux::Server.source-file": [
+      {
+        "command": "source-file",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:514",
+          "lib/LibTmux/Server.rakumod:519"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.start": [
+      {
+        "command": "new-session",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:665",
+          "lib/LibTmux/Server.rakumod:626",
+          "lib/LibTmux/Server.rakumod:65",
+          "lib/LibTmux/Server.rakumod:72"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.wait-for": [
+      {
+        "command": "wait-for",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:524",
+          "lib/LibTmux/Server.rakumod:528",
+          "lib/LibTmux/Server.rakumod:533",
+          "lib/LibTmux/Server.rakumod:478"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ],
+    "LibTmux::Server.wait-for-async": [
+      {
+        "command": "wait-for",
+        "evidence": [
+          "lib/LibTmux/Server.rakumod:528",
+          "lib/LibTmux/Server.rakumod:533"
+        ],
+        "reviewed": true,
+        "scope": null
+      }
+    ]
+  }
+}
diff --git a/site/src/lib/api-glossary-native.ts b/site/src/lib/api-glossary-native.ts
index ce3e21505..519c1063e 100644
--- a/site/src/lib/api-glossary-native.ts
+++ b/site/src/lib/api-glossary-native.ts
@@ -24,9 +24,26 @@ const luaAnnotation = (section: string) => `https://luals.github.io/wiki/annotat
 const elixirDocs = (page: string) => `https://elixir.hexdocs.pm/${page}`
 const erlangReference = (page: string) => `https://github.com/erlang/otp/blob/OTP-29.1.2/system/doc/reference_manual/${page}.md`
 const swiftBook = (page: string) => `https://docs.swift.org/latest/documentation/the-swift-programming-language/${page}/`
+const rakuDocs = (page: string) => `https://docs.raku.org/${page}`
 const clhs = (page: string) => `https://www.lispworks.com/documentation/HyperSpec/Body/${page}.htm`
 
 export const NATIVE_API_GLOSSARIES: Record<string, Record<string, Definition>> = {
+  raku: {
+    module: term('A Raku compilation unit that declares packages and exports declarations with is export.', 'Raku modules', rakuDocs('language/modules'), 'The module badge names a namespace. LibTmux re-exports the public declarations of its modules, so use LibTmux gives programs the common names. A distribution and a module are different identities.'),
+    class: term('A Raku class: a package that creates objects with its own attributes and methods.', 'Raku type system', rakuDocs('language/typesystem'), 'A captured model class reads local state. A reference class such as PaneRef names a tmux object and sends commands on request.'),
+    method: term('A Raku method invoked on an object or a type object with a dot.', 'Raku objects', rakuDocs('language/objects'), 'The invocant is implicit. A method that talks to tmux says so in its summary; one that reads a captured snapshot does not. A name ending in -async returns a Promise.'),
+    property: term('A public attribute accessor or a method declared as a field of a captured record.', 'Raku objects', rakuDocs('language/objects'), 'Reading it returns the value the snapshot captured and performs no I/O.'),
+    constant: term('A named Raku value or enumeration member that cannot be reassigned.', 'Raku variables', rakuDocs('language/variables'), 'An enumeration member is also listed under its enum.'),
+    enum: term('A Raku enumeration: a set of named constants of one type.', 'Raku type system', rakuDocs('language/typesystem'), 'Members compare by identity and keep their declared order.'),
+    typealias: term('A Raku subset or type constraint that gives a checked name to a narrower type.', 'Raku type system', rakuDocs('language/typesystem'), 'The constraint runs when a value is bound. It does not create a new class.'),
+    function: term('A Raku sub: a routine called by name with no invocant.', 'Raku functions', rakuDocs('language/functions'), 'A function with a hyphenated name is called as written, such as decode-layout.'),
+    exception: term('A Raku exception class that callers throw, catch with CATCH or try, and inspect by type.', 'Raku exceptions', rakuDocs('language/exceptions'), 'LibTmux exceptions live under X::LibTmux and carry the fields the failure produced.'),
+    trait: term('A Raku trait modifies a declaration with is, does or of.', 'Raku traits', rakuDocs('language/traits'), 'A trait changes how the declaration behaves; it is not a Rust or Java trait.'),
+    inherited: term('A method found through Raku class inheritance.', 'Raku type system', rakuDocs('language/typesystem'), 'The page names the declaring class. A subclass reuses the method and its documented behavior unchanged.'),
+    overload: term('One of several multi declarations that share a name and differ in their signatures.', 'Raku functions', rakuDocs('language/functions'), 'Raku selects the candidate from the argument types at the call. Read each signature for the types it accepts.'),
+    async: term('An operation that returns a Promise and completes on the Raku scheduler.', 'Raku concurrency', rakuDocs('language/concurrency'), 'Await the Promise or consume it with react and whenever. Completion of the Promise and release of its resources are separate; close what the operation owns.'),
+    package: term('The installable Raku distribution supplying this API, identified by name and authority.', 'Raku modules', rakuDocs('language/modules'), 'The distribution LibTmux:auth<zef:libtmux> provides these modules.'),
+  },
   ocaml: {
     package: term('An installable OCaml library package. Its public modules supply the declarations in this reference.', 'OCaml libraries with Dune', 'https://ocaml.org/docs/libraries-dune', 'A package name and an OCaml module path are distinct: libtmux-unix provides Libtmux_unix.'),
     module: term('An OCaml module exposing values, types and nested modules through a signature.', 'OCaml module types', 'https://ocaml.org/manual/5.5/modtypes.html#s:modtypes'),
diff --git a/site/src/lib/api-models.ts b/site/src/lib/api-models.ts
index 2f0dcf3c9..69ffaa0ac 100644
--- a/site/src/lib/api-models.ts
+++ b/site/src/lib/api-models.ts
@@ -1,5 +1,7 @@
 import perlModel from '../data/api/perl.json'
 import perlNav from '../data/api/perl.nav.json'
+import rakuModel from '../data/api/raku.json'
+import rakuNav from '../data/api/raku.nav.json'
 import { conceptsFor, isMemberOwner, OWNER_KINDS, parameterId, parentInventory, sourceUrl, SymbolIndex, type ApiModel, type ApiModelBase, type ApiSymbol, type InventoryEntry } from '@libtmux/api-model/reference'
 import mentionIndex from '../data/mentions.json'
 import domInv from '../data/inventories/dom.entries.json'
@@ -67,6 +69,7 @@ import clojureNav from '../data/api/clojure.nav.json'
  */
 export const API_MODELS: Record<string, ApiModel> = {
   perl: perlModel as unknown as ApiModel,
+  raku: rakuModel as unknown as ApiModel,
   erlang: erlangModel as unknown as ApiModel,
   powershell: powershellModel as unknown as ApiModel,
   julia: juliaModel as unknown as ApiModel,
@@ -136,6 +139,7 @@ export interface PortNavData {
  */
 export const API_NAV: Record<string, PortNavData> = {
   perl: perlNav as unknown as PortNavData,
+  raku: rakuNav as unknown as PortNavData,
   erlang: erlangNav as unknown as PortNavData,
   powershell: powershellNav as unknown as PortNavData,
   julia: juliaNav as unknown as PortNavData,
@@ -163,6 +167,7 @@ export { isMemberOwner, OWNER_KINDS } from '@libtmux/api-model/reference'
 
 export const PORT_NAME: Record<string, string> = {
   perl: 'Perl',
+  raku: 'Raku',
   erlang: 'Erlang',
   powershell: 'PowerShell',
   julia: 'Julia',
@@ -213,8 +218,9 @@ export function ownersOf(model: ApiModelBase) {
 export function topLevelTypesOf(model: ApiModelBase) {
   const owners = new Set(ownersOf(model).map((symbol) => symbol.id))
   const packages = new Set(model.symbols.filter((symbol) => symbol.kind === 'module').map((symbol) => symbol.id))
-  const lisp = 'port' in model && model.port === 'lisp'
-  return model.symbols.filter((s) => (!s.parent || (lisp && packages.has(s.parent))) && OWNER_KINDS.has(s.kind)
+  // Common Lisp and Raku declare their types under the public module that exports them.
+  const underPackage = 'port' in model && (model.port === 'lisp' || model.port === 'raku')
+  return model.symbols.filter((s) => (!s.parent || (underPackage && packages.has(s.parent))) && OWNER_KINDS.has(s.kind)
     && (s.kind !== 'typealias' || owners.has(s.id)))
 }
 
diff --git a/site/src/lib/api-sections.ts b/site/src/lib/api-sections.ts
index fd9b42e8e..8e9969be4 100644
--- a/site/src/lib/api-sections.ts
+++ b/site/src/lib/api-sections.ts
@@ -228,7 +228,7 @@ export function aliasDeclaration(symbol: ApiSymbol, language?: string): { name:
 
 /** Keep native declaration syntax consistent in HTML and copied Markdown. */
 export function usesNativeSignatures(symbol: ApiSymbol, port?: string): boolean {
-  return (port === 'rs' && Boolean(symbol.variant)) || supportsRustSignatures(symbol, port) || supportsTypeScriptSignatures(symbol, port) || supportsGoSignatures(symbol, port) || supportsJavaSignatures(symbol, port) || supportsCSharpSignatures(symbol, port) || supportsRubySignatures(symbol, port) || supportsLuaSignatures(symbol, port) || supportsElixirSignatures(symbol, port) || supportsErlangSignatures(symbol, port) || ['perl', 'kotlin', 'scala', 'fsharp', 'ocaml', 'c', 'powershell', 'julia', 'clojure', 'lisp'].includes(port ?? '') ||
+  return (port === 'rs' && Boolean(symbol.variant)) || supportsRustSignatures(symbol, port) || supportsTypeScriptSignatures(symbol, port) || supportsGoSignatures(symbol, port) || supportsJavaSignatures(symbol, port) || supportsCSharpSignatures(symbol, port) || supportsRubySignatures(symbol, port) || supportsLuaSignatures(symbol, port) || supportsElixirSignatures(symbol, port) || supportsErlangSignatures(symbol, port) || ['perl', 'kotlin', 'scala', 'fsharp', 'ocaml', 'c', 'powershell', 'julia', 'clojure', 'lisp', 'raku'].includes(port ?? '') ||
     (port === 'haskell' && symbol.signatures.length > 0) || (port === 'cxx' && symbol.signatures.length > 0 && symbol.signatures.every((signature) => Boolean(signature.raw)))
 }
 
diff --git a/site/src/lib/brand-palettes.json b/site/src/lib/brand-palettes.json
index 641837fff..3dd854481 100644
--- a/site/src/lib/brand-palettes.json
+++ b/site/src/lib/brand-palettes.json
@@ -570,5 +570,31 @@
       "solid": "#1c523f",
       "onSolid": "#ffffff"
     }
+  },
+  "raku": {
+    "name": "Raku",
+    "color": "#0000fb",
+    "light": {
+      "background": "#fafbfc",
+      "surface": "#f3f5f7",
+      "hover": "#e9edf1",
+      "border": "#d6dce3",
+      "text": "#202830",
+      "muted": "#53606d",
+      "link": "#0000b0",
+      "solid": "#0000b0",
+      "onSolid": "#ffffff"
+    },
+    "dark": {
+      "background": "#15191d",
+      "surface": "#1c2229",
+      "hover": "#29323d",
+      "border": "#3e4a57",
+      "text": "#e7edf3",
+      "muted": "#b7c1cd",
+      "link": "#8c8cfd",
+      "solid": "#0000b0",
+      "onSolid": "#ffffff"
+    }
   }
 }
diff --git a/site/src/lib/code-language.ts b/site/src/lib/code-language.ts
index ec6c6166b..223484d91 100644
--- a/site/src/lib/code-language.ts
+++ b/site/src/lib/code-language.ts
@@ -4,6 +4,7 @@ const EC_LANGS = new Set([
   'csharp', 'cpp', 'c', 'go', 'bash', 'shell', 'console', 'json', 'yaml',
   'toml', 'xml', 'diff', 'text', 'tmux-usage', 'tmux-shell', 'tmux-config', 'powershell', 'julia', 'elixir', 'properties', 'ini',
   'cmake', 'ocaml', 'lisp', 'haskell', 'clojure', 'erlang',
+  'raku',
 ])
 
 const EC_ALIASES: Record<string, string> = {
diff --git a/site/src/lib/code-layout.ts b/site/src/lib/code-layout.ts
index 129ba1ae9..ca551f4a7 100644
--- a/site/src/lib/code-layout.ts
+++ b/site/src/lib/code-layout.ts
@@ -327,6 +327,17 @@ export async function apiSignatureLayouts(symbol: ApiSymbol, language?: string):
         failures: await codeWidthFailures(signature.raw, 'api'), syntax: signature.nativeSyntax }] as const
     })))
   }
+  if (language === 'raku' && symbol.signatures.length) {
+    // The compiler's declaration text and the adapter's reference spans must agree byte for byte.
+    return new Map(await Promise.all(symbol.signatures.map(async (signature) => {
+      if (!signature.raw) throw new Error(`Missing native Raku declaration: ${symbol.id}`)
+      if (signature.nativeSpans?.map((span) => span.text).join('') !== signature.raw) {
+        throw new Error(`Unavailable native Raku spans: ${symbol.id}`)
+      }
+      return [signature, { text: signature.raw, limit: CODE_COLUMNS.api, nativeSpans: signature.nativeSpans,
+        failures: await codeWidthFailures(signature.raw, 'api'), syntax: signature.nativeSyntax }] as const
+    })))
+  }
   if (supportsErlangSignatures(symbol, language)) {
     return new Map(await Promise.all(symbol.signatures.map(async (signature) => {
       const text = signature.raw!
diff --git a/site/src/lib/core-statement.ts b/site/src/lib/core-statement.ts
index 39c8cb430..e3bff80c4 100644
--- a/site/src/lib/core-statement.ts
+++ b/site/src/lib/core-statement.ts
@@ -49,6 +49,7 @@ const SYNTAX: Readonly<Record<string, StatementSyntax>> = {
   lisp: { comment: ';', quotes: '"', literal: '#\\' },
   erlang: { comment: '%', quotes: '"\'', literal: '$' },
   perl: { comment: '#', quotes: '"\'', literal: '$' },
+  raku: { comment: '#', quotes: '"\'' },
   ocaml: { quotes: '"', block: { open: '(*', close: '*)', strings: true }, ticks: true, braces: true },
   haskell: { comment: '--', quotes: '"', operator: '!#$%&*+./<=>?@\\^|-~:', block: { open: '{-', close: '-}' }, ticks: true },
   clojure: { comment: ';', quotes: '"', literal: '\\' },
diff --git a/site/src/lib/native-name.ts b/site/src/lib/native-name.ts
index 2a660c0f2..b0032b79d 100644
--- a/site/src/lib/native-name.ts
+++ b/site/src/lib/native-name.ts
@@ -103,6 +103,8 @@ export function nativeShortName(model: { port?: string; symbols: readonly ApiSym
   // Erlang places the record marker before the module: #tmux_model:pane{}.
   if (model?.port === 'erlang' && symbol.kind === 'struct') return qualifiedNameOf(symbol)
   const id = qualifiedNameOf(symbol), ownerId = qualifiedNameOf(owner)
+  // Raku writes an exception by its X:: path, not through the module that exports it.
+  if (model?.port === 'raku' && !id.startsWith(ownerId)) return id
   // OCaml constructors and record fields live in their module's namespace, not their type's.
   if (model?.port === 'ocaml') return id.split('.').slice(-2).join('.')
   // Swift writes a member's labels in its name and fewer of them in its id, so the id is not always the owner and the name.
diff --git a/site/src/lib/perl-pod.ts b/site/src/lib/perl-pod.ts
new file mode 100644
index 000000000..7f615b499
--- /dev/null
+++ b/site/src/lib/perl-pod.ts
@@ -0,0 +1,143 @@
+/**
+ * Links from a Perl reference page to the POD of the CPAN release that ships
+ * the same declaration.
+ *
+ * Everything here is computed from two committed inputs and requests nothing:
+ * the Perl API model, which records each declaration's distribution, parent,
+ * owning file and the SHA-256 of every source file it read, and
+ * `data/perl-pod.json`, which `scripts/gen-perl-pod.mjs` wrote from MetaCPAN's
+ * API for each distribution's latest release. A link appears only when the
+ * release documents the declaration's package, and a method links to its own
+ * section only when the release's rendered POD has that fragment.
+ *
+ * The release may not be what the page documents. When the declaring file's
+ * SHA-256 is the release's, the page and the release describe the same bytes.
+ * When it differs, the link still opens the release's POD, is labelled with the
+ * release version, and gives a method a link only if the release's POD has its
+ * section: a declaration the file gained since the release is not in the POD.
+ */
+import type { ApiModel, ApiSymbol } from '@libtmux/api-model'
+import data from '../data/perl-pod.json'
+
+export interface PodDocument {
+  /** The file in the release, relative to the distribution root. */
+  path: string
+  sha256: string
+  /** Fragments of the rendered page: heading and `=item` ids, in order. */
+  anchors: readonly string[]
+}
+
+export interface PodRelease {
+  author: string
+  release: string
+  documents: Readonly<Record<string, PodDocument>>
+  /** Every package the release provides, and the document that documents it. */
+  packages: Readonly<Record<string, string | null>>
+}
+
+export interface PodData {
+  schema: 1
+  distributions: Readonly<Record<string, PodRelease>>
+}
+
+export const POD_DATA = data as PodData
+
+/** An alternate documentation link beside a declaration's source link. */
+export interface ApiAlternate {
+  /** Which documentation host and kind the link opens. */
+  kind: 'metacpan-pod'
+  href: string
+  /** The visible text: the host and kind, and the release when the page documents other bytes. */
+  label: string
+  /** The accessible name and tooltip: it starts with the label, then names the module, its distribution and release. */
+  title: string
+  module: string
+  distribution: string
+  release: string
+  section?: string
+  /** The page's declaring file is not the release's. */
+  differs: boolean
+}
+
+/** A decimal release tag, such as the Perl tag for release 0.003: a documentation version pinned to a release. */
+const RELEASE_TAG = /^v\d+\.\d+$/
+
+const filesOf = new WeakMap<object, ReadonlyMap<string, string>>()
+/** The SHA-256 of each source file the model read, by repository path. */
+function fileHashes(model: Pick<ApiModel, 'nativeProvenance'>): ReadonlyMap<string, string> {
+  let files = filesOf.get(model)
+  if (!files) {
+    files = new Map((model.nativeProvenance?.files ?? []).map((file) => [file.path, file.sha256]))
+    filesOf.set(model, files)
+  }
+  return files
+}
+
+/** `packages/core/lib/LibTmux/Server.pm` in the repository is `lib/LibTmux/Server.pm` in its distribution. */
+const inDistribution = (file: string): string | undefined => /^.*?\/(lib\/.+)$/.exec(file)?.[1]
+
+/**
+ * The package a declaration belongs to: a method's declaring package, which
+ * for an inherited method is the base class, and for anything else itself.
+ */
+function ownerOf(model: Pick<ApiModel, 'symbols'>, symbol: ApiSymbol): ApiSymbol | undefined {
+  const id = symbol.kind === 'method' ? symbol.inheritedFrom ?? symbol.parent : symbol.id
+  return id === symbol.id ? symbol : model.symbols.find((candidate) => candidate.id === id)
+}
+
+/**
+ * The MetaCPAN POD link for a declaration, or nothing when the release does not
+ * document it.
+ *
+ * `version` is the documentation version the page belongs to. A page for a
+ * release tag pins the link to the recorded release, so it does not change when
+ * a newer one is uploaded; a page for trunk opens whatever MetaCPAN calls the
+ * latest release, which the record names.
+ */
+export function podLink(
+  model: Pick<ApiModel, 'symbols' | 'nativeProvenance'>,
+  symbol: ApiSymbol,
+  version = 'latest',
+  pod: PodData = POD_DATA,
+): ApiAlternate | undefined {
+  const owner = ownerOf(model, symbol)
+  const dist = owner?.package
+  const release = dist ? pod.distributions[dist] : undefined
+  const path = owner && inDistribution(owner.source.file)
+  if (!owner || !dist || !release || !path) return undefined
+  // CPAN says which document documents a package, and the document must be the owner's own file.
+  const module = release.packages[owner.id]
+  const document = module ? release.documents[module] : undefined
+  if (!module || !document || document.path !== path) return undefined
+
+  const differs = fileHashes(model).get(owner.source.file) !== document.sha256
+  let section: string | undefined
+  if (symbol.id !== module) {
+    // A method has a section of its own in the POD of the package that declares it. A package declared in the document
+    // of another, as an exception subclass is, has its own heading when the release gave it one. A heading in a
+    // shared document may belong to another package, so a subclass's method does not claim it.
+    const heading = symbol.kind === 'method' ? (owner.id === module ? symbol.name : undefined) : symbol.name
+    section = heading !== undefined && document.anchors.includes(heading) && !document.anchors.includes(`${heading}-1`) ? heading : undefined
+    // With no section, the declaration is in the release only if its file is the release's own.
+    if (section === undefined && differs) return undefined
+  }
+
+  const pinned = RELEASE_TAG.test(version)
+  const page = pinned
+    ? `https://metacpan.org/release/${release.author}/${dist}-${release.release}/view/${document.path}`
+    : `https://metacpan.org/pod/${module}`
+  const label = differs ? `MetaCPAN POD ${release.release}` : 'MetaCPAN POD'
+  const target = section === undefined ? module : `${module}, section ${section},`
+  return {
+    kind: 'metacpan-pod',
+    href: section === undefined ? page : `${page}#${section}`,
+    label,
+    title: `${label}: ${target} in ${dist} ${release.release}${differs ? '; this page documents other source' : ''}`,
+    module, distribution: dist, release: release.release, section, differs,
+  }
+}
+
+/** The alternate documentation link a port's reference page offers beside a declaration, if its ecosystem hosts one. */
+export function alternateDocs(model: Pick<ApiModel, 'port' | 'symbols' | 'nativeProvenance'>, symbol: ApiSymbol, version = 'latest'): ApiAlternate | undefined {
+  return model.port === 'perl' ? podLink(model, symbol, version) : undefined
+}
diff --git a/site/src/lib/port-documentation.ts b/site/src/lib/port-documentation.ts
index c522d18eb..e072cb9f4 100644
--- a/site/src/lib/port-documentation.ts
+++ b/site/src/lib/port-documentation.ts
@@ -442,6 +442,21 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     ],
     redirects: [{ path: 'mcp', target: '' }, { path: 'workspace', target: '' }],
   },
+  raku: {
+    domains: [
+      libraryDomain('Typed tmux snapshots, local selections and explicit commands for Raku programs.'),
+    ],
+    sections: {
+      guides: 'Install LibTmux and create, find and arrange tmux sessions and panes.',
+      examples: 'Run complete Raku programs with their documented results and cleanup.',
+      topics: 'Check which tmux releases and platforms the library supports.',
+    },
+    sourceGuides: [
+      guide('README.md', 'guides/getting-started', 'core', { title: 'Getting started', aliases: [], sidebar: { group: 'Guides', order: 1 } }),
+      guide('examples/README.md', 'examples/programs', 'core', { title: 'Runnable programs', description: 'Run the checked Raku programs and compare each with its expected result.', aliases: [] }),
+      guide('docs/adr/0001-tmux-compatibility.md', 'topics/compatibility', 'core', { title: 'tmux compatibility', aliases: [] }),
+    ],
+  },
 }
 
 export const SOURCE_GUIDE_PORTS = Object.keys(PORT_DOCUMENTATION)
diff --git a/site/src/lib/port-families.ts b/site/src/lib/port-families.ts
index ba6cba382..c1379ac87 100644
--- a/site/src/lib/port-families.ts
+++ b/site/src/lib/port-families.ts
@@ -10,7 +10,7 @@ export interface PortFamily {
  * by how they are built and run. A port belongs to one group.
  */
 export const PORT_FAMILIES: readonly PortFamily[] = [
-  { label: 'Scripting & web', ports: ['py', 'ruby', 'lua', 'julia', 'ts', 'perl'] },
+  { label: 'Scripting & web', ports: ['py', 'ruby', 'lua', 'julia', 'ts', 'perl', 'raku'] },
   { label: 'Compiled & native', ports: ['rs', 'go', 'cxx', 'lisp', 'swift', 'ocaml', 'haskell'] },
   { label: 'JVM', ports: ['java', 'kotlin', 'scala', 'clojure'] },
   { label: '.NET', ports: ['csharp', 'fsharp', 'powershell'] },
diff --git a/site/src/lib/port-inventory.ts b/site/src/lib/port-inventory.ts
index 1c380fbe6..d1bc78195 100644
--- a/site/src/lib/port-inventory.ts
+++ b/site/src/lib/port-inventory.ts
@@ -79,9 +79,15 @@ export type PublicationStatus = 'published' | 'configured-unpublished' | 'planne
 export type PackageHostId =
   | 'pypi' | 'rubygems' | 'luarocks' | 'powershell-gallery' | 'npm' | 'crates' | 'pkg-go-dev'
   | 'maven-central' | 'nuget' | 'swift-package-index' | 'hex'
+  | 'metacpan'
+  | 'raku-land'
 export type ApiHostId = 'docs-rs' | 'pkg-go-dev' | 'javadoc-io' | 'swift-package-index' | 'hexdocs'
+  | 'metacpan'
 export type HostIcon = 'github' | 'pypi' | 'npm' | 'crates' | 'go' | 'maven' | 'nuget' | 'swift' | 'rubygems' | 'luarocks'
   | 'powershell' | 'docsrs' | 'javadoc' | 'docc' | 'hex' | 'hexdocs'
+  | 'cpan'
+  | 'pod'
+  | 'raku-land'
 
 export interface HostIdentity {
   name: string
@@ -108,6 +114,8 @@ export const PACKAGE_HOSTS: Readonly<Record<PackageHostId, HostIdentity>> = {
   nuget: { name: 'NuGet', hostname: 'www.nuget.org', icon: 'nuget' },
   'swift-package-index': { name: 'Swift Package Index', hostname: 'swiftpackageindex.com', icon: 'swift' },
   hex: { name: 'Hex', hostname: 'hex.pm', icon: 'hex' },
+  metacpan: { name: 'MetaCPAN', hostname: 'metacpan.org', icon: 'cpan' },
+  'raku-land': { name: 'Raku Land', hostname: 'raku.land', icon: 'raku-land' },
 }
 
 export const API_HOSTS: Readonly<Record<ApiHostId, HostIdentity>> = {
@@ -118,6 +126,8 @@ export const API_HOSTS: Readonly<Record<ApiHostId, HostIdentity>> = {
   'swift-package-index': { name: 'Swift Package Index', hostname: 'swiftpackageindex.com', icon: 'docc' },
   // The package page wears the Hex mark; its HexDocs reference wears an open book, so the two chips differ at icon size.
   hexdocs: { name: 'HexDocs', hostname: 'hexdocs.pm', icon: 'hexdocs', subdomains: true },
+  // The distribution page wears the CPAN mark; the POD of its modules wears a page, so the two chips differ at icon size.
+  metacpan: { name: 'MetaCPAN POD', hostname: 'metacpan.org', icon: 'pod' },
 }
 
 export type InventoryProduct = 'core' | DocProduct
@@ -219,6 +229,22 @@ const hexPackage = (name: string): Located & Pick<InventoryEntry, 'api'> => ({
   package: { host: 'hex', url: `https://hex.pm/packages/${name}` },
   api: { host: 'hexdocs', url: `https://${name}.hexdocs.pm/` },
 })
+/** A CPAN distribution on MetaCPAN, and the POD of its main module, which MetaCPAN renders from the release. */
+const cpan = (dist: string, module: string): Located & Pick<InventoryEntry, 'api'> => ({
+  coordinate: dist,
+  package: { host: 'metacpan', url: `https://metacpan.org/dist/${dist}` },
+  api: { host: 'metacpan', url: `https://metacpan.org/pod/${module}` },
+})
+/** A Hex package whose owner has published no HexDocs, so only the package page is real. */
+const hexRelease = (name: string): Located => ({
+  coordinate: name,
+  package: { host: 'hex', url: `https://hex.pm/packages/${name}` },
+})
+/** A distribution on Raku Land under its Fez authority; the site serves no API reference for it. */
+const rakuDist = (authority: string, name: string): Located => ({
+  coordinate: name,
+  package: { host: 'raku-land', url: `https://raku.land/${authority}/${name}` },
+})
 const MAVEN_GROUP = 'io.github.libtmux'
 const central = (artifact: string): Located => ({
   coordinate: `${MAVEN_GROUP}:${artifact}`,
@@ -235,6 +261,14 @@ const spiTarget = (target: string): Pick<InventoryEntry, 'api'> => ({
   api: { host: 'swift-package-index', url: `${SPI}/documentation/${target.toLowerCase()}`, tool: 'DocC' },
 })
 
+/**
+ * An entry installed from public Git because no registry carries it. Its source
+ * is linked and nothing else: `published` means a registry release, which this
+ * entry does not have.
+ */
+const fromGit = (build: ReturnType<typeof family>, note: string) =>
+  (draft: Draft & { repo?: string }): InventoryEntry => build({ status: 'configured-unpublished', sourceAvailable: true, note, ...draft })
+
 const PY = 'tmux-python/libtmux'
 const py = family(PY)
 const tmuxp = family('tmux-python/tmuxp')
@@ -243,9 +277,13 @@ const ruby = family('libtmux/libtmux-ruby')
 const lua = family('libtmux/libtmux-lua')
 const powershell = family('libtmux/libtmux-powershell')
 const julia = family('libtmux/libtmux-julia')
+const juliaSource = fromGit(julia, 'Installs from Git; the General registry does not carry it.')
 const elixir = family('libtmux/libtmux-elixir', 'main')
+const raku = family('libtmux/libtmux-raku')
 const haskell = family('libtmux/libtmux-haskell')
+const haskellSource = fromGit(haskell, 'Installs from source; Hackage does not carry it.')
 const lisp = family('libtmux/libtmux-lisp')
+const lispSource = fromGit(lisp, 'Installs from source; Quicklisp does not carry it.')
 const erlang = family('libtmux/libtmux-erlang')
 const ts = family('libtmux/libtmux-ts')
 const rs = family('libtmux/libtmux-rs')
@@ -254,6 +292,8 @@ const jvm = family('libtmux/libtmux-java')
 const dotnet = family('libtmux/libtmux-dotnet')
 const cxx = family('libtmux/libtmux-cxx')
 const swift = family('libtmux/libtmux-swift')
+const perl = family('libtmux/libtmux-perl')
+const ocaml = fromGit(family('libtmux/libtmux-ocaml'), 'Installs from source; the opam repository does not carry it.')
 
 export type DestinationKind = 'source' | 'package' | 'api'
 
@@ -297,26 +337,30 @@ const GO = 'github.com/libtmux/libtmux-go'
  * testing products in the order a reader reaches for them.
  */
 export const INVENTORY: Readonly<Record<string, readonly InventoryEntry[]>> = {
+  raku: [
+    raku({ id: 'LibTmux', kind: 'library', product: 'core', unit: 'Raku distribution', label: 'LibTmux', ...rakuDist('zef:libtmux', 'LibTmux'), aliases: ['use LibTmux', 'LibTmux:auth<zef:libtmux>'], path: 'lib' }),
+    raku({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-raku', coordinate: 'libtmux/libtmux-raku' }),
+  ],
   ocaml: [
-    { id: 'libtmux', kind: 'library', product: 'core', unit: 'opam package', label: 'libtmux', coordinate: 'libtmux',
-      aliases: ['Libtmux'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'lib', status: 'published' },
-    { id: 'libtmux-unix', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-unix', coordinate: 'libtmux-unix',
-      aliases: ['Libtmux_unix'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'unix', status: 'published' },
-    { id: 'libtmux-eio', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-eio', coordinate: 'libtmux-eio',
-      aliases: ['Libtmux_eio'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'eio', status: 'published' },
-    { id: 'libtmux-json', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-json', coordinate: 'libtmux-json',
-      aliases: ['Libtmux_json'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'json', status: 'published' },
-    { id: 'libtmux-workspace', kind: 'companion', product: 'workspace', unit: 'opam package', label: 'libtmux-workspace', coordinate: 'libtmux-workspace',
-      aliases: ['Libtmux_workspace'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'workspace', status: 'published' },
-    { id: 'libtmux-workspace-cli', kind: 'cli', product: 'workspace', unit: 'opam package', label: 'libtmux-workspace-cli', coordinate: 'libtmux-workspace-cli',
-      aliases: ['tmux-workspace'], repo: 'libtmux/libtmux-ocaml', ref: 'master', path: 'cli', status: 'published' },
+    ocaml({ id: 'libtmux', kind: 'library', product: 'core', unit: 'opam package', label: 'libtmux', aliases: ['Libtmux'], path: 'lib' }),
+    ocaml({ id: 'libtmux-unix', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-unix', aliases: ['Libtmux_unix'], path: 'unix' }),
+    ocaml({ id: 'libtmux-eio', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-eio', aliases: ['Libtmux_eio'], path: 'eio' }),
+    ocaml({ id: 'libtmux-json', kind: 'companion', product: 'core', unit: 'opam package', label: 'libtmux-json', aliases: ['Libtmux_json'], path: 'json' }),
+    ocaml({ id: 'libtmux-workspace', kind: 'companion', product: 'workspace', unit: 'opam package', label: 'libtmux-workspace', aliases: ['Libtmux_workspace'], path: 'workspace' }),
+    ocaml({ id: 'libtmux-workspace-cli', kind: 'cli', product: 'workspace', unit: 'opam package', label: 'libtmux-workspace-cli', aliases: ['tmux-workspace'], path: 'cli' }),
   ],
   perl: [
-    { id: 'LibTmux', kind: 'library', product: 'core', label: 'LibTmux', coordinate: 'LibTmux', aliases: ["LibTmux::Server"], repo: 'libtmux/libtmux-perl', ref: 'master', path: 'packages/core', status: 'configured-unpublished', sourceAvailable: true, note: 'Install from verified source; no CPAN release is published.' },
-    { id: 'LibTmux-Async', kind: 'companion', product: 'core', label: 'LibTmux-Async', coordinate: 'LibTmux-Async', aliases: ["LibTmux::Async::Server"], repo: 'libtmux/libtmux-perl', ref: 'master', path: 'packages/async', status: 'configured-unpublished', sourceAvailable: true, note: 'Install from verified source; no CPAN release is published.' },
-    { id: 'LibTmux-Workspace', kind: 'companion', product: 'workspace', label: 'LibTmux-Workspace', coordinate: 'LibTmux-Workspace', aliases: ["LibTmux::Workspace"], repo: 'libtmux/libtmux-perl', ref: 'master', path: 'packages/workspace', status: 'configured-unpublished', sourceAvailable: true, note: 'Install from verified source; no CPAN release is published.' },
-    { id: 'repository', kind: 'source', product: 'core', label: 'libtmux-perl', coordinate: 'libtmux/libtmux-perl', aliases: [], repo: 'libtmux/libtmux-perl', ref: 'master', status: 'published' },
-    { id: 'libtmux-workspace', kind: 'cli', product: 'workspace', label: 'libtmux-workspace', coordinate: 'libtmux-workspace', aliases: ['libtmux-workspace'], within: 'LibTmux-Workspace', unit: 'command', repo: 'libtmux/libtmux-perl', ref: 'master', path: 'packages/workspace/bin/libtmux-workspace', file: true, status: 'configured-unpublished', sourceAvailable: true, note: 'Install from verified source; no CPAN release is published.' },
+    perl({ id: 'LibTmux', kind: 'library', product: 'core', unit: 'distribution', label: 'LibTmux', ...cpan('LibTmux', 'LibTmux'),
+      aliases: ['LibTmux::Server'], path: 'packages/core' }),
+    perl({ id: 'LibTmux-Async', kind: 'companion', product: 'core', unit: 'distribution', label: 'LibTmux-Async', ...cpan('LibTmux-Async', 'LibTmux::Async'),
+      aliases: ['LibTmux::Async::Server'], path: 'packages/async' }),
+    perl({ id: 'LibTmux-Workspace', kind: 'companion', product: 'workspace', unit: 'distribution', label: 'LibTmux-Workspace', ...cpan('LibTmux-Workspace', 'LibTmux::Workspace'),
+      aliases: ['LibTmux::Workspace'], path: 'packages/workspace' }),
+    perl({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-perl', coordinate: 'libtmux/libtmux-perl' }),
+    // The command ships in the workspace distribution, so it is found on that distribution's page.
+    perl({ id: 'libtmux-workspace', kind: 'cli', product: 'workspace', label: 'libtmux-workspace', unit: 'command', within: 'LibTmux-Workspace',
+      aliases: ['libtmux-workspace'], path: 'packages/workspace/bin/libtmux-workspace', file: true,
+      coordinate: 'libtmux-workspace', package: { host: 'metacpan', url: 'https://metacpan.org/dist/LibTmux-Workspace' } }),
   ],
   py: [
     py({ id: 'libtmux', kind: 'library', product: 'core', label: 'libtmux', ...pypi('libtmux'), aliases: ['libtmux'] }),
@@ -364,24 +408,25 @@ export const INVENTORY: Readonly<Record<string, readonly InventoryEntry[]>> = {
   ],
   julia: [
     // None of the three packages is registered in General; they install from the repository by URL and subdirectory.
-    julia({ id: 'LibTmux', kind: 'library', product: 'core', unit: 'package', label: 'LibTmux', path: 'src', aliases: ['using LibTmux'] }),
+    juliaSource({ id: 'LibTmux', kind: 'library', product: 'core', unit: 'package', label: 'LibTmux', path: 'src', aliases: ['using LibTmux'] }),
     julia({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-julia', coordinate: 'libtmux/libtmux-julia' }),
     // Defined in src/criteria.jl and loaded with LibTmux.
-    julia({ id: 'LibTmux.Filters', kind: 'module', product: 'core', unit: 'module', within: 'LibTmux', label: 'LibTmux.Filters',
+    juliaSource({ id: 'LibTmux.Filters', kind: 'module', product: 'core', unit: 'module', within: 'LibTmux', label: 'LibTmux.Filters',
       path: 'src/criteria.jl', file: true, aliases: ['using LibTmux.Filters'] }),
     // Package extensions, loaded when JSON or Tables is; each is a file of ext/.
-    julia({ id: 'LibTmuxJSONExt', kind: 'module', product: 'core', unit: 'extension', within: 'LibTmux', label: 'LibTmuxJSONExt',
+    juliaSource({ id: 'LibTmuxJSONExt', kind: 'module', product: 'core', unit: 'extension', within: 'LibTmux', label: 'LibTmuxJSONExt',
       path: 'ext/LibTmuxJSONExt.jl', file: true, aliases: ['JSON'] }),
-    julia({ id: 'LibTmuxTablesExt', kind: 'module', product: 'core', unit: 'extension', within: 'LibTmux', label: 'LibTmuxTablesExt',
+    juliaSource({ id: 'LibTmuxTablesExt', kind: 'module', product: 'core', unit: 'extension', within: 'LibTmux', label: 'LibTmuxTablesExt',
       path: 'ext/LibTmuxTablesExt.jl', file: true, aliases: ['Tables'] }),
-    julia({ id: 'LibTmuxMCP', kind: 'mcp-server', product: 'mcp', unit: 'package', label: 'LibTmuxMCP', path: 'packages/LibTmuxMCP',
+    juliaSource({ id: 'LibTmuxMCP', kind: 'mcp-server', product: 'mcp', unit: 'package', label: 'LibTmuxMCP', path: 'packages/LibTmuxMCP',
       aliases: ['using LibTmuxMCP', 'libtmux-mcp'] }),
-    julia({ id: 'LibTmuxWorkspace', kind: 'companion', product: 'workspace', unit: 'package', label: 'LibTmuxWorkspace',
+    juliaSource({ id: 'LibTmuxWorkspace', kind: 'companion', product: 'workspace', unit: 'package', label: 'LibTmuxWorkspace',
       path: 'packages/LibTmuxWorkspace', aliases: ['using LibTmuxWorkspace', 'libtmux-workspace'] }),
   ],
   erlang: [
-    erlang({ id: 'libtmux_erlang', kind: 'library', product: 'core', label: 'libtmux_erlang', path: 'apps/libtmux_erlang',
-      aliases: ['Erlang/OTP', 'Rebar3'], note: 'Installs from Git with Rebar3 git_subdir; no Hex release.' }),
+    // Hex has no documentation for the package (docs_html_url is null), so no HexDocs reference is linked.
+    erlang({ id: 'libtmux_erlang', kind: 'library', product: 'core', label: 'libtmux_erlang', ...hexRelease('libtmux_erlang'),
+      path: 'apps/libtmux_erlang', aliases: ['Erlang/OTP', 'Rebar3'] }),
     erlang({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-erlang', coordinate: 'libtmux/libtmux-erlang' }),
   ],
   elixir: [
@@ -397,7 +442,7 @@ export const INVENTORY: Readonly<Record<string, readonly InventoryEntry[]>> = {
       unavailable: [{ kind: 'package', host: 'hex', url: 'https://hex.pm/packages/libtmux_workspace', reason: 'not published' }] }),
   ],
   haskell: [
-    haskell({ id: 'libtmux-haskell', kind: 'library', product: 'core', unit: 'Cabal package', label: 'libtmux-haskell', path: 'src',
+    haskellSource({ id: 'libtmux-haskell', kind: 'library', product: 'core', unit: 'Cabal package', label: 'libtmux-haskell', path: 'src',
       aliases: ['LibTmux', 'LibTmux.Server', 'LibTmux.Snapshot', 'LibTmux.Query', 'LibTmux.Snapshot.Fixture', 'LibTmux.Id', 'LibTmux.Value', 'LibTmux.Version'], note: 'Available from source; not published on Hackage.',
       unavailable: [{ kind: 'package', host: 'Hackage', url: 'https://hackage.haskell.org/package/libtmux-haskell', reason: 'not published' }] }),
     haskell({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-haskell', coordinate: 'libtmux/libtmux-haskell' }),
@@ -405,23 +450,23 @@ export const INVENTORY: Readonly<Record<string, readonly InventoryEntry[]>> = {
       note: 'Planned workspace library and CLI; no package or executable is implemented.' }),
   ],
   lisp: [
-    lisp({ id: 'libtmux', kind: 'library', product: 'core', unit: 'source distribution', label: 'libtmux',
+    lispSource({ id: 'libtmux', kind: 'library', product: 'core', unit: 'source distribution', label: 'libtmux',
       path: 'src', aliases: ['libtmux'], note: 'The 0.1.0 ASDF systems are source-installed and unreleased.' }),
     lisp({ id: 'repository', kind: 'source', product: 'core', label: 'libtmux-lisp', coordinate: 'libtmux/libtmux-lisp' }),
-    lisp({ id: 'libtmux/query', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/query', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/query', path: 'libtmux.asd', file: true, aliases: ['libtmux.query'] }),
-    lisp({ id: 'libtmux/regex', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/regex', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/regex', path: 'libtmux.asd', file: true, aliases: ['libtmux.regex'] }),
-    lisp({ id: 'libtmux/json', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/json', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/json', path: 'libtmux.asd', file: true, aliases: ['libtmux.json'] }),
-    lisp({ id: 'libtmux/control', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/control', kind: 'companion', product: 'core', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/control', path: 'libtmux.asd', file: true, aliases: ['libtmux.control'] }),
-    lisp({ id: 'libtmux/workspace', kind: 'companion', product: 'workspace', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/workspace', kind: 'companion', product: 'workspace', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/workspace', path: 'src/workspace.lisp', file: true,
       aliases: ['libtmux.workspace', '(asdf:load-system "libtmux/workspace")'] }),
-    lisp({ id: 'libtmux/workspace/cli', kind: 'companion', product: 'workspace', unit: 'ASDF system', within: 'libtmux',
+    lispSource({ id: 'libtmux/workspace/cli', kind: 'companion', product: 'workspace', unit: 'ASDF system', within: 'libtmux',
       label: 'libtmux/workspace/cli', path: 'src/workspace-cli.lisp', file: true, aliases: ['libtmux.workspace.cli'] }),
-    lisp({ id: 'workspace-command', kind: 'cli', product: 'workspace', unit: 'script', within: 'libtmux',
+    lispSource({ id: 'workspace-command', kind: 'cli', product: 'workspace', unit: 'script', within: 'libtmux',
       label: 'libtmux-workspace', coordinate: 'mise exec -- tools/lisp.sh tools/workspace-cli.lisp',
       path: 'bin/libtmux-workspace', file: true, aliases: ['libtmux-workspace', 'tools/workspace-cli.lisp'] }),
   ],
diff --git a/site/src/lib/ports.ts b/site/src/lib/ports.ts
index 194e82540..fee14fcc1 100644
--- a/site/src/lib/ports.ts
+++ b/site/src/lib/ports.ts
@@ -39,6 +39,8 @@ export interface PackageRegistry {
   url: string
   /** Which mark `components/icons/RegistryIcon.astro` draws. */
   icon: 'pypi' | 'npm' | 'crates' | 'go' | 'maven' | 'nuget' | 'swift' | 'rubygems' | 'luarocks' | 'powershell' | 'hex'
+    | 'cpan'
+    | 'raku-land'
 }
 
 export type PortPackageId = 'core' | 'async' | DocProduct
@@ -381,6 +383,16 @@ const ERLANG_SOURCE_INSTALL = `{deps, [
 const ERLANG_GIT_INSTALL: InstallForm = {
   code: ERLANG_SOURCE_INSTALL.replaceAll('{revision}', '"master"'), lang: 'erlang',
 }
+// An exact pin, as the package README gives: the API is still developing.
+const ERLANG_HEX_INSTALL: InstallForm = { code: '{deps, [{libtmux_erlang, "{version}"}]}.', lang: 'erlang' }
+
+const JULIA_GIT_INSTALL: InstallForm = {
+  code: 'using Pkg\nPkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="master"))', lang: 'julia',
+}
+
+const HASKELL_GIT_INSTALL: InstallForm = {
+  code: 'packages: .\n\nsource-repository-package\n  type: git\n  location: https://github.com/libtmux/libtmux-haskell\n  tag: master', lang: 'text',
+}
 
 const CORE_PORTS: readonly Port[] = [
   {
@@ -659,10 +671,10 @@ const CORE_PORTS: readonly Port[] = [
       note: 'Run in Julia with tmux on PATH. The package is not registered in General, so this installs from Git; Manifest.toml records the package tree hash.' }],
     initProject: { code: 'using Pkg\nPkg.activate(".")', lang: 'julia' },
     installForms: {
-      release: { code: 'using Pkg\nPkg.add("LibTmux")', lang: 'julia' },
-      prerelease: { code: 'using Pkg\nPkg.add(PackageSpec(name="LibTmux", version="{version}"))', lang: 'julia' },
-      // Unselected source installs follow the default branch.
-      git: { code: 'using Pkg\nPkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="master"))', lang: 'julia' },
+      // General does not carry LibTmux, so every form installs from Git. Unselected source installs follow the default branch.
+      release: JULIA_GIT_INSTALL,
+      prerelease: JULIA_GIT_INSTALL,
+      git: JULIA_GIT_INSTALL,
     },
     installNote: 'Requires Julia 1.13.1 and tmux 3.3a or newer. JSON layouts require tmux 3.8. Companion packages install from the same revision as the core.',
   },
@@ -685,13 +697,20 @@ const CORE_PORTS: readonly Port[] = [
     renderer: 'astro',
     publishesOwnTree: true,
     generator: 'OTP documentation chunks and native typespecs',
-    installs: [{ label: 'rebar.config', filename: 'rebar.config', lang: 'erlang',
-      code: ERLANG_SOURCE_INSTALL,
-      additionalBlocks: [{ lang: 'console', code: 'rebar3 compile' }],
-      note: 'Merge this deps entry into rebar.config. Requires Erlang/OTP 29.1.2, Rebar3 3.28.0, Linux, tmux 3.3a–3.8, make and a C11 compiler. Commit rebar.lock to retain the resolved Git revision. The application is unreleased; no Hex package is advertised.' }],
+    installs: [
+      { label: 'Rebar3 (Hex)', filename: 'rebar.config', lang: 'erlang',
+        code: ERLANG_HEX_INSTALL.code,
+        additionalBlocks: [{ lang: 'console', code: 'rebar3 compile' }],
+        note: 'Merge this deps entry into rebar.config. Requires Erlang/OTP 29.1.2, Rebar3 3.28.0, Linux, tmux 3.3a–3.8, make and a C11 compiler. The API is still developing, so the entry pins an exact version. Commit rebar.lock to retain the resolved package checksum.' },
+      { label: 'Rebar3 (Git)', filename: 'rebar.config', lang: 'erlang',
+        code: ERLANG_SOURCE_INSTALL,
+        additionalBlocks: [{ lang: 'console', code: 'rebar3 compile' }],
+        note: 'Installs the documented source revision instead of the Hex release. Merge this deps entry into rebar.config. Commit rebar.lock to retain the resolved Git revision.' },
+    ],
+    registry: { name: 'Hex', url: 'https://hex.pm/packages/libtmux_erlang', icon: 'hex' },
     initProject: { code: 'rebar3 new lib tmux_example && cd tmux_example', lang: 'console' },
-    installForms: { release: ERLANG_GIT_INSTALL, prerelease: ERLANG_GIT_INSTALL, git: ERLANG_GIT_INSTALL },
-    installNote: 'Add libtmux_erlang to your application dependencies and start it with application:ensure_all_started/1. Native records are experimental in OTP 29. The Git subdirectory selects the core application from its umbrella repository.',
+    installForms: { release: ERLANG_HEX_INSTALL, prerelease: ERLANG_HEX_INSTALL, git: ERLANG_GIT_INSTALL },
+    installNote: 'Add libtmux_erlang to your application dependencies and start it with application:ensure_all_started/1. Native records are experimental in OTP 29. The Git alternative selects the core application from its umbrella repository with a subdirectory.',
   },
   {
     slug: 'elixir',
@@ -768,9 +787,10 @@ const CORE_PORTS: readonly Port[] = [
     }],
     initProject: { lang: 'console', code: 'cabal init --non-interactive --exe --language=GHC2024 --dependency="base >=4.22 && <4.23, libtmux-haskell ^>=0.1.0.0"' },
     installForms: {
-      release: { lang: 'text', code: 'build-depends: libtmux-haskell ^>={version}' },
-      prerelease: { lang: 'text', code: 'build-depends: libtmux-haskell =={version}' },
-      git: { lang: 'text', code: 'packages: .\n\nsource-repository-package\n  type: git\n  location: https://github.com/libtmux/libtmux-haskell\n  tag: master' },
+      // Hackage does not carry libtmux-haskell, so every form installs from Git.
+      release: HASKELL_GIT_INSTALL,
+      prerelease: HASKELL_GIT_INSTALL,
+      git: HASKELL_GIT_INSTALL,
     },
     installNote: 'The source provides scoped Server handles, detached snapshots, typed queries, checked renames and pane titles, and validated offline fixtures. Creation, events and workspace tooling remain in development; MCP is excluded.',
   },
@@ -1411,27 +1431,78 @@ target_link_libraries(your_target PRIVATE libtmux::libtmux)`,
     source: { path: 'packages/core', ref: 'master' }, versionedDocs: true,
     docsDispatch: { workflow: 'docs.yml' },
     tagGrammar: 'semver', publishesOwnTree: true,
+    // MetaCPAN renders the POD shipped in each release. This site renders the same documentation and links to it.
+    ecosystemHost: {
+      name: 'MetaCPAN POD',
+      url: 'https://metacpan.org/pod/LibTmux',
+      rationale: 'POD for each module of the published distributions on MetaCPAN.',
+    },
     renderer: 'astro', generator: 'Perl PPI signatures and native POD', referenceKind: 'model',
-    workspaceCli: 'libtmux-workspace load', workspaceCliAvailability: 'local',
+    workspaceCli: 'libtmux-workspace load', workspaceCliAvailability: 'published',
     productAvailability: { workspace: 'available', mcp: 'excluded' },
     packages: [
-      { id: 'core', name: 'LibTmux', require: 'LibTmux::Server', source: { path: 'packages/core', ref: 'master' } },
-      { id: 'async', name: 'LibTmux-Async', require: 'LibTmux::Async::Server', source: { path: 'packages/async', ref: 'master' },
-        installs: [{ label: 'cpm (source)', lang: 'console', code: 'cpm install --global ./packages/async', note: 'From the source checkout after core installation; adds Future and IO::Async with its required Ppoll backend.' }] },
-      { id: 'workspace', name: 'LibTmux-Workspace', require: 'LibTmux::Workspace', executable: 'libtmux-workspace',
-        source: { path: 'packages/workspace', ref: 'master' },
-        installs: [{ label: 'cpm (source)', lang: 'console', code: 'cpm install --global ./packages/workspace', note: 'From the source checkout after core installation. No CPAN release.' }] },
+      { id: 'core', name: 'LibTmux', registry: 'https://metacpan.org/dist/LibTmux', reference: 'https://metacpan.org/pod/LibTmux',
+        require: 'LibTmux::Server', source: { path: 'packages/core', ref: 'master' } },
+      { id: 'async', name: 'LibTmux-Async', registry: 'https://metacpan.org/dist/LibTmux-Async', reference: 'https://metacpan.org/pod/LibTmux::Async',
+        require: 'LibTmux::Async::Server', source: { path: 'packages/async', ref: 'master' },
+        installs: [
+          { label: 'cpm', lang: 'console', code: 'cpm install --global LibTmux::Async',
+            note: 'Adds Future and IO::Async with its required Ppoll backend. The installer resolves the core distribution it depends on.' },
+          { label: 'cpm (source)', lang: 'console', code: 'cpm install --global ./packages/async',
+            note: 'From the source checkout after core installation.' },
+        ] },
+      { id: 'workspace', name: 'LibTmux-Workspace', registry: 'https://metacpan.org/dist/LibTmux-Workspace', reference: 'https://metacpan.org/pod/LibTmux::Workspace',
+        require: 'LibTmux::Workspace', executable: 'libtmux-workspace', source: { path: 'packages/workspace', ref: 'master' },
+        installs: [
+          { label: 'cpm', lang: 'console', code: 'cpm install --global LibTmux::Workspace',
+            note: 'Installs the libtmux-workspace command. The installer resolves the core distribution it depends on.' },
+          { label: 'cpm (source)', lang: 'console', code: 'cpm install --global ./packages/workspace',
+            note: 'From the source checkout after core installation.' },
+        ] },
     ],
-    installs: [{ label: 'cpm (source)', lang: 'console',
-      code: 'git clone https://github.com/libtmux/libtmux-perl.git && \\\n  cd libtmux-perl && \\\n  cpm install --global ./packages/core',
-      note: 'Unpublished development distribution. Requires Perl 5.44.0, Linux x86_64 LP64, and tmux 3.3a or newer.' }],
-    initProject: { lang: 'text', code: 'Create a Perl program using LibTmux::Server; install from the source checkout.' },
+    installs: [
+      { label: 'cpm', lang: 'console', code: 'cpm install --global LibTmux',
+        note: 'Requires Perl 5.44.0, Linux x86_64 LP64, and tmux 3.3a or newer.' },
+      { label: 'cpm (source)', lang: 'console',
+        code: 'git clone https://github.com/libtmux/libtmux-perl.git && \\\n  cd libtmux-perl && \\\n  cpm install --global ./packages/core',
+        note: 'Installs the development tree from Git rather than the CPAN release.' },
+    ],
+    registry: { name: 'MetaCPAN', url: 'https://metacpan.org/dist/LibTmux', icon: 'cpan' },
+    initProject: { lang: 'text', code: 'Create a Perl program using LibTmux::Server; install LibTmux from CPAN.' },
+    // PAUSE indexes releases only, so no resolver skips a prerelease and both forms install the newest indexed release.
     installForms: {
-      release: { lang: 'console', code: 'cpm install --global ./packages/core' },
-      prerelease: { lang: 'console', code: 'cpm install --global ./packages/core' },
+      release: { lang: 'console', code: 'cpm install --global LibTmux' },
+      prerelease: { lang: 'console', code: 'cpm install --global LibTmux' },
       git: { lang: 'console', code: 'git clone https://github.com/libtmux/libtmux-perl.git && \\\n  cd libtmux-perl && \\\n  cpm install --global ./packages/core' },
     },
-    installNote: 'Install core before workspace or optional async. These package names do not identify published CPAN releases.',
+    installNote: 'Workspace and the optional async distribution each depend on core, which the installer resolves. Keep one Perl interpreter and installation prefix for all of them.',
+  },
+  {
+    slug: 'raku', projectName: 'libtmux-raku', logoLanguage: 'raku', shortName: 'Raku',
+    name: 'Raku', language: 'Raku', packageName: 'LibTmux',
+    repo: 'libtmux/libtmux-raku', checkout: '~/work/libtmux/libtmux-raku',
+    worktree: '~/work/libtmux/libtmux-raku-docs-site',
+    source: { path: 'lib', ref: 'master' }, versionedDocs: true,
+    docsDispatch: { workflow: 'docs.yml' },
+    tagGrammar: 'semver', publishesOwnTree: true,
+    renderer: 'astro', generator: 'Rakudo RakuAST and native RakuDoc', referenceKind: 'model',
+    productAvailability: { workspace: 'excluded', mcp: 'excluded' },
+    registry: { name: 'Raku Land', url: 'https://raku.land/zef:libtmux/LibTmux', icon: 'raku-land' },
+    packages: [{ id: 'core', name: 'LibTmux', coordinate: 'LibTmux:auth<zef:libtmux>', require: 'LibTmux', source: { path: 'lib', ref: 'master' } }],
+    installs: [
+      { label: 'zef', lang: 'console', code: "zef install 'LibTmux:auth<zef:libtmux>'",
+        note: 'Requires Linux, Raku 6.d and tmux 3.3a through 3.8. The authority names the Fez publisher, zef:libtmux.' },
+      { label: 'zef (source)', lang: 'console',
+        code: 'git clone https://github.com/libtmux/libtmux-raku.git && \\\n  cd libtmux-raku && \\\n  zef install .',
+        note: 'Install a checkout instead of the published distribution.' },
+    ],
+    initProject: { lang: 'text', code: 'Add "LibTmux:auth<zef:libtmux>" to the depends array of META6.json.' },
+    installForms: {
+      release: { lang: 'console', code: "zef install 'LibTmux:auth<zef:libtmux>'" },
+      prerelease: { lang: 'console', code: "zef install 'LibTmux:ver<{version}>:auth<zef:libtmux>'" },
+      git: { lang: 'console', code: 'git clone --branch {tag} --depth 1 https://github.com/libtmux/libtmux-raku.git && \\\n  cd libtmux-raku && \\\n  zef install .' },
+    },
+    installNote: 'The API is experimental and may change between 0.x releases. CI qualifies Rakudo 2026.09 on Linux with tmux 3.3a and 3.8; other platforms and compiler versions are unverified. Workspace and MCP products are not published.',
   },
 
 ] as const
@@ -1704,8 +1775,8 @@ export function workspaceInstallGuidance(port: Port): string | undefined {
   if (!productAvailable(port, 'workspace') || !port.workspaceCli) return undefined
   const command = port.workspaceCliRun ?? port.workspaceCli.split(/\s+/)[0]
   if (port.workspaceCliAvailability === 'published') {
-    return `The \`${command}\` CLI is published to ${port.registry?.name ?? 'the package registry'}, `
-      + 'numbered 0.1.N. Pin its version when automation depends on its output.'
+    return `The \`${command}\` CLI is published to ${port.registry?.name ?? 'the package registry'}. `
+      + 'Pin its version when automation depends on its output.'
   }
   if (port.workspaceCliAvailability !== 'local') return undefined
   const cliPackage = port.packages?.find((pkg) => pkg.executable === command || pkg.executable === port.workspaceCli)
diff --git a/site/src/lib/registry.ts b/site/src/lib/registry.ts
index 0b3c1f785..d11778587 100644
--- a/site/src/lib/registry.ts
+++ b/site/src/lib/registry.ts
@@ -59,14 +59,16 @@ export function installSelection(
 
 /** Resolve package snippets against the selected docs source or registry snapshot. */
 export function installsFor(port: Port, selection: { version?: string; pin?: boolean; revision?: string } = {}): readonly InstallCommand[] {
-  if (port.installs.some((command) => command.code.includes('{revision}'))) {
-    const revision = JSON.stringify(selection.revision ?? port.source?.ref ?? 'HEAD')
+  const revision = JSON.stringify(selection.revision ?? port.source?.ref ?? 'HEAD')
+  const versioned = port.installs.some((command) => command.code.includes('{version}') || command.additionalBlocks?.some((block) => block.code.includes('{version}')))
+  if (!versioned && port.installs.some((command) => command.code.includes('{revision}'))) {
     return port.installs.map((command) => ({ ...command, code: command.code.replaceAll('{revision}', revision) }))
   }
-  if (!port.installs.some((command) => command.code.includes('{version}') || command.additionalBlocks?.some((block) => block.code.includes('{version}')))) return port.installs
+  if (!versioned) return port.installs
   const entry = registryFor(port)
   const version = selection.version ?? entry.version
-  const fill = (code: string) => code.replaceAll('{version}', version!)
+  // A port may offer a registry release beside a source install, so one pass fills both.
+  const fill = (code: string) => code.replaceAll('{version}', version!).replaceAll('{revision}', revision)
   if (!version) {
     const source = installCommand(port, entry)
     return [{ label: 'Source', ...source, code: source.lang === 'console' ? wrapShell(source.code) : source.code }]
diff --git a/site/src/lib/symbol-form.ts b/site/src/lib/symbol-form.ts
index 05fb6a70e..28ca473e5 100644
--- a/site/src/lib/symbol-form.ts
+++ b/site/src/lib/symbol-form.ts
@@ -39,6 +39,7 @@ interface Language {
 /** Every port. A language missing here is a failure of this table, and the test requires one entry per port. */
 export const FORMS: Record<string, Language | 'as-written'> = {
   perl: 'as-written',
+  raku: 'as-written',
   py: { qualifier: '.', call: true },
   ts: { qualifier: '.', call: true },
   rs: { qualifier: '::', call: true },
diff --git a/site/src/lib/tmux-library-usage.ts b/site/src/lib/tmux-library-usage.ts
index 762092c4b..ebcf41179 100644
--- a/site/src/lib/tmux-library-usage.ts
+++ b/site/src/lib/tmux-library-usage.ts
@@ -27,6 +27,7 @@ import ocaml from '../data/tmux-usage/ocaml.json'
 import powershell from '../data/tmux-usage/powershell.json'
 import perl from '../data/tmux-usage/perl.json'
 import py from '../data/tmux-usage/py.json'
+import raku from '../data/tmux-usage/raku.json'
 import rs from '../data/tmux-usage/rs.json'
 import ruby from '../data/tmux-usage/ruby.json'
 import scala from '../data/tmux-usage/scala.json'
@@ -73,7 +74,7 @@ export interface TmuxScope {
 }
 
 export const TMUX_USAGE: Record<string, UsageDocument> = {
-  csharp, clojure, cxx, elixir, erlang, fsharp, go, haskell, java, julia, kotlin, lisp, lua, ocaml, powershell, perl, py, rs, ruby, scala, swift, ts,
+  csharp, clojure, cxx, elixir, erlang, fsharp, go, haskell, java, julia, kotlin, lisp, lua, ocaml, powershell, perl, py, raku, rs, ruby, scala, swift, ts,
 } as unknown as Record<string, UsageDocument>
 
 const SCOPES = scopeTable.commands as Record<string, { scopes: TmuxScope[] }>
diff --git a/site/src/pages/meta/support.astro b/site/src/pages/meta/support.astro
index 4f97d969a..96d5787fd 100644
--- a/site/src/pages/meta/support.astro
+++ b/site/src/pages/meta/support.astro
@@ -41,13 +41,15 @@ const breadcrumbs = [{ name: 'libtmux', url: withRoot('/') }, { name: 'Support a
       <strong>beta</strong> or <strong>rc</strong>. A final release shows its series instead, such as
       <strong>0.x</strong> for <code>0.1.0</code>: it is released, and any release may change or
       remove exported identifiers, so pin an exact version. When the registry lists no release at
-      all, the badge shows the stage of the repository's newest release tag instead, and a tag that is
+      all and the toolchain resolves releases from repository tags, as C++ does, the badge shows the
+      stage of the newest release tag instead, and a tag that is
       exactly <code>MAJOR.MINOR.PATCH</code>, with an optional leading <code>v</code> or package label,
       such as <code>v0.1.0</code>, shows its series. A tag newer than the
       registry's newest version does not count: a registry that lists only <code>0.1.0-alpha.2</code>
-      shows <strong>alpha</strong> even after the repository tags <code>v0.1.0</code>. A package with
-      no release and no release tag shows <strong>unreleased</strong>. A language without an
-      implementation has no badge.
+      shows <strong>alpha</strong> even after the repository tags <code>v0.1.0</code>. A package that
+      no registry carries and that installs from source shows <strong>unreleased</strong>, whatever
+      tags its repository holds, and so does a package with no release and no release tag. A language
+      without an implementation has no badge.
     </p>
     <p class="mt-3">
       Python's <code>tmuxp</code> workspace loader and Python MCP server show their own PyPI release
diff --git a/site/src/styles/api.css b/site/src/styles/api.css
index b2bfd27c3..8edadbfa4 100644
--- a/site/src/styles/api.css
+++ b/site/src/styles/api.css
@@ -561,6 +561,11 @@ dl.gp-sphinx-api-container > dt.gp-sphinx-api-header:only-child {
   border-radius: 2px;
 }
 
+/* The alternate link follows `[source]` inside the same cluster, set off by a space the brackets do not carry. */
+.api-alternate-link {
+  margin-inline-start: 0.5rem;
+}
+
 @media (prefers-reduced-motion: reduce) {
   .api-type-link,
   .api-source-anchor {
diff --git a/site/src/styles/brand.css b/site/src/styles/brand.css
index 6b3612828..1313e3942 100644
--- a/site/src/styles/brand.css
+++ b/site/src/styles/brand.css
@@ -2749,3 +2749,128 @@ html[data-brand="lisp"][data-theme-mode="dark"], html[data-brand="lisp"][data-th
   --lt-color-code-bg: #1c2229;
   }
 }
+html[data-brand="raku"] {
+  color-scheme: light;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #0000b0;
+  --theme-secondary: #53606d;
+  --theme-accent: #0000b0;
+  --theme-background: #fafbfc;
+  --theme-text: #202830;
+  --background-color: #fafbfc;
+  --text-color: #202830;
+  --topnav-background: #fafbfc;
+  --topnav-text-color: #202830;
+  --topnav-link-color: #53606d;
+  --topnav-link-hover-color: #202830;
+  --color-background-primary: #fafbfc;
+  --color-background-secondary: #f3f5f7;
+  --color-background-border: #d6dce3;
+  --color-api-background-hover: #e9edf1;
+  --color-foreground-primary: #202830;
+  --color-foreground-secondary: #53606d;
+  --color-foreground-muted: #53606d;
+  --color-link: #0000b0;
+  --color-brand-primary: #0000b0;
+  --color-brand-content: #0000b0;
+  --color-inline-code-background: #f3f5f7;
+  --lt-color-bg: #fafbfc;
+  --lt-color-bg-secondary: #f3f5f7;
+  --lt-color-bg-hover: #e9edf1;
+  --lt-color-fg: #202830;
+  --lt-color-fg-secondary: #53606d;
+  --lt-color-fg-muted: #53606d;
+  --lt-color-border: #d6dce3;
+  --lt-color-accent: #0000b0;
+  --lt-color-link: #0000b0;
+  --lt-color-link-visited: #0000b0;
+  --lt-color-code-bg: #f3f5f7;
+}
+html[data-brand="raku"][data-theme-mode="dark"], html[data-brand="raku"][data-theme="dark"] {
+  color-scheme: dark;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #8c8cfd;
+  --theme-secondary: #b7c1cd;
+  --theme-accent: #8c8cfd;
+  --theme-background: #15191d;
+  --theme-text: #e7edf3;
+  --background-color: #15191d;
+  --text-color: #e7edf3;
+  --topnav-background: #15191d;
+  --topnav-text-color: #e7edf3;
+  --topnav-link-color: #b7c1cd;
+  --topnav-link-hover-color: #e7edf3;
+  --color-background-primary: #15191d;
+  --color-background-secondary: #1c2229;
+  --color-background-border: #3e4a57;
+  --color-api-background-hover: #29323d;
+  --color-foreground-primary: #e7edf3;
+  --color-foreground-secondary: #b7c1cd;
+  --color-foreground-muted: #b7c1cd;
+  --color-link: #8c8cfd;
+  --color-brand-primary: #8c8cfd;
+  --color-brand-content: #8c8cfd;
+  --color-inline-code-background: #1c2229;
+  --lt-color-bg: #15191d;
+  --lt-color-bg-secondary: #1c2229;
+  --lt-color-bg-hover: #29323d;
+  --lt-color-fg: #e7edf3;
+  --lt-color-fg-secondary: #b7c1cd;
+  --lt-color-fg-muted: #b7c1cd;
+  --lt-color-border: #3e4a57;
+  --lt-color-accent: #8c8cfd;
+  --lt-color-link: #8c8cfd;
+  --lt-color-link-visited: #8c8cfd;
+  --lt-color-code-bg: #1c2229;
+}
+@media (prefers-color-scheme: dark) {
+  html[data-brand="raku"]:not([data-theme-mode]):not([data-theme="light"]) {
+  color-scheme: dark;
+  --brand-color: #0000fb;
+  --brand-solid: #0000b0;
+  --brand-on-solid: #ffffff;
+  --button-bg-primary: #0000b0;
+  --button-text-primary: #ffffff;
+  --theme-primary: #8c8cfd;
+  --theme-secondary: #b7c1cd;
+  --theme-accent: #8c8cfd;
+  --theme-background: #15191d;
+  --theme-text: #e7edf3;
+  --background-color: #15191d;
+  --text-color: #e7edf3;
+  --topnav-background: #15191d;
+  --topnav-text-color: #e7edf3;
+  --topnav-link-color: #b7c1cd;
+  --topnav-link-hover-color: #e7edf3;
+  --color-background-primary: #15191d;
+  --color-background-secondary: #1c2229;
+  --color-background-border: #3e4a57;
+  --color-api-background-hover: #29323d;
+  --color-foreground-primary: #e7edf3;
+  --color-foreground-secondary: #b7c1cd;
+  --color-foreground-muted: #b7c1cd;
+  --color-link: #8c8cfd;
+  --color-brand-primary: #8c8cfd;
+  --color-brand-content: #8c8cfd;
+  --color-inline-code-background: #1c2229;
+  --lt-color-bg: #15191d;
+  --lt-color-bg-secondary: #1c2229;
+  --lt-color-bg-hover: #29323d;
+  --lt-color-fg: #e7edf3;
+  --lt-color-fg-secondary: #b7c1cd;
+  --lt-color-fg-muted: #b7c1cd;
+  --lt-color-border: #3e4a57;
+  --lt-color-accent: #8c8cfd;
+  --lt-color-link: #8c8cfd;
+  --lt-color-link-visited: #8c8cfd;
+  --lt-color-code-bg: #1c2229;
+  }
+}
diff --git a/site/test/api-db-mentions.test.ts b/site/test/api-db-mentions.test.ts
index 99cb98ebf..5fa134b7d 100644
--- a/site/test/api-db-mentions.test.ts
+++ b/site/test/api-db-mentions.test.ts
@@ -46,7 +46,10 @@ describe('prose mention index', () => {
     expect(mentionIndex.mentions.some((row) => row.port === 'csharp'
       && row.symbol === 'LibTmux.Workspace.WorkspaceActionKind.CaptureResult'
       && row.page === '/powershell/latest/workspace/source-guide/')).toBe(true)
-    expect(mentionIndex.dangling.filter((row) => ['powershell', 'julia', 'elixir', 'perl'].includes(row.port))).toEqual([])
+    // Perl's guides name a CPAN changelog file, a wire-format identifier and a filter criterion path in code spans; none is API.
+    const notApi = new Set(['Changes', 'libtmux.where/v1', 'pane.where.width.-gte'])
+    expect(mentionIndex.dangling.filter((row) => ['powershell', 'julia', 'elixir', 'perl'].includes(row.port)
+      && !(row.port === 'perl' && notApi.has(row.text)))).toEqual([])
     expect(mentionIndex.mentions.some((row) => row.port === 'perl'
       && row.symbol === 'LibTmux::Filter'
       && row.page === '/perl/latest/guides/filtering/')).toBe(true)
diff --git a/site/test/api-glossary-navigation.test.ts b/site/test/api-glossary-navigation.test.ts
index cb504d768..44d5adb5d 100644
--- a/site/test/api-glossary-navigation.test.ts
+++ b/site/test/api-glossary-navigation.test.ts
@@ -42,6 +42,7 @@ import * as constants from '../src/constants'
 import * as toc from '../src/utils/generateToC'
 import * as branding from '../src/lib/branding'
 import * as mentionBadge from '../src/lib/mention-badge'
+import * as perlPod from '../src/lib/perl-pod'
 import mentions from '../src/data/mentions.json'
 
 const windows: Window[] = []
@@ -65,7 +66,7 @@ async function components(stubs: Readonly<Record<string, string>> = {}) {
       'api-labels': labels, 'word-break': wordBreak, 'native-name': nativeName, ports, 'product-api': products,
       versions, 'site-root': roots, sidebar, 'documentation-navigation': documentation,
       'page-ports-for': pagePorts, 'markdown-twins': markdown, 'tmux-manual-data': manual, 'tmux-reference': reference, 'tmux-catalog': catalog,
-      branding, 'mention-badge': mentionBadge,
+      branding, 'mention-badge': mentionBadge, 'perl-pod': perlPod,
     }).map(([name, exports]) => [new URL(`../src/lib/${name}.ts`, import.meta.url).href, exports])),
     ...Object.fromEntries(Object.entries({ locales, resolve, contribute, ui }).map(([name, exports]) =>
       [new URL(`../src/i18n/${name}.ts`, import.meta.url).href, exports])),
diff --git a/site/test/api-glossary.test.ts b/site/test/api-glossary.test.ts
index e3097e98d..012bc0ff6 100644
--- a/site/test/api-glossary.test.ts
+++ b/site/test/api-glossary.test.ts
@@ -37,6 +37,7 @@ const nativeAuthorities: Record<string, RegExp> = {
   haskell: /^https:\/\/(?:www\.haskell\.org|downloads\.haskell\.org|cabal\.readthedocs\.io)\//,
   lisp: /^https:\/\/(?:www\.lispworks\.com\/documentation\/HyperSpec|asdf\.common-lisp\.dev)\//,
   erlang: /^https:\/\/(?:www\.erlang\.org|github\.com\/erlang\/otp)\//,
+  raku: /^https:\/\/docs\.raku\.org\//,
 }
 
 afterEach(async () => {
diff --git a/site/test/branding.test.ts b/site/test/branding.test.ts
index 2450ea43e..f6ac66877 100644
--- a/site/test/branding.test.ts
+++ b/site/test/branding.test.ts
@@ -33,6 +33,7 @@ describe('route branding', () => {
       csharp: 'libtmux-dotnet: C#-based tmux client', fsharp: 'libtmux-fsharp: F#-based tmux client',
       cxx: 'libtmux-cxx: C++-based tmux client', swift: 'libtmux-swift: Swift-based tmux client',
       ocaml: 'libtmux-ocaml: OCaml-based tmux client',
+      raku: 'libtmux-raku: Raku-based tmux client',
     })
     expect(portTagline(PORTS.find((port) => port.slug === 'rs')!)).toBe('Rust-based tmux client')
     // The home title carries no ` | project` suffix, for Julia's differing project name too.
@@ -54,6 +55,7 @@ describe('route branding', () => {
       scala: 'libtmux-scala', csharp: 'libtmux-dotnet', fsharp: 'libtmux-fsharp',
       cxx: 'libtmux-cxx', swift: 'libtmux-swift', clojure: 'libtmux-clojure',
       ocaml: 'libtmux-ocaml',
+      raku: 'libtmux-raku',
     }
     expect(Object.fromEntries(PORTS.map((port) => [port.slug, branding(port.slug).projectName]))).toEqual(names)
     expect(branding('java', 'reference/libtmux-scala-cats').projectName).toBe('libtmux-scala')
diff --git a/site/test/concept-coverage.test.ts b/site/test/concept-coverage.test.ts
index 35d7c7ef9..cc14d1039 100644
--- a/site/test/concept-coverage.test.ts
+++ b/site/test/concept-coverage.test.ts
@@ -27,7 +27,7 @@ function coverage(concept: string) {
 describe('the ports that have a page for an operation', () => {
   it('lists every port for a server snapshot except those with no whole-server snapshot', () => {
     const { pages, reasons } = coverage('snapshot')
-    expect(pages.toSorted()).toEqual(['clojure', 'csharp', 'elixir', 'erlang', 'fsharp', 'go', 'java', 'julia', 'kotlin', 'lisp', 'lua', 'ocaml', 'perl', 'powershell', 'rs', 'ruby', 'scala', 'swift', 'ts'])
+    expect(pages.toSorted()).toEqual(['clojure', 'csharp', 'elixir', 'erlang', 'fsharp', 'go', 'java', 'julia', 'kotlin', 'lisp', 'lua', 'ocaml', 'perl', 'powershell', 'raku', 'rs', 'ruby', 'scala', 'swift', 'ts'])
     // Haskell exposes scalar modules; Python and C++ have no whole-server snapshot.
     expect(reasons.toSorted()).toEqual(['cxx', 'haskell', 'py'])
     for (const port of ['py', 'cxx']) expect(CONCEPTS.snapshot!.absent![port], port).toMatch(/^no equivalent on `Server`/)
diff --git a/site/test/core-recipes-new-ports.test.ts b/site/test/core-recipes-new-ports.test.ts
index 158cece3d..41d1c6d2a 100644
--- a/site/test/core-recipes-new-ports.test.ts
+++ b/site/test/core-recipes-new-ports.test.ts
@@ -8,6 +8,7 @@ import { RECIPES as PERL, withoutMarks as withoutPerlMarks } from '../../scripts
 import { RECIPES as OCAML, ocamlHelper, withoutMarks as withoutOcamlMarks } from '../../scripts/lib/core-recipes/ocaml.mjs'
 import { RECIPES as HASKELL, withoutMarks as withoutHaskellMarks } from '../../scripts/lib/core-recipes/haskell.mjs'
 import { RECIPES as CLOJURE, clojureHelper, withoutMarks as withoutClojureMarks } from '../../scripts/lib/core-recipes/clojure.mjs'
+import { RECIPES as RAKU, withoutMarks as withoutRakuMarks } from '../../scripts/lib/core-recipes/raku.mjs'
 import * as corePlayer from '../src/lib/core-player'
 import { playableCapability, tmuxChanges, viewSteps } from '../src/lib/core-player'
 import { recordingProblems, sha256, type CoreRecording } from '../src/lib/core-recording'
@@ -17,7 +18,7 @@ import home from '../src/data/home-examples.json'
 import { loadAstroTemplate, renderAstroTemplate } from './astro-templates'
 
 /** The ports whose landing program the player plays that this file covers. */
-type NewPort = 'lisp' | 'perl' | 'erlang' | 'ocaml' | 'haskell' | 'clojure'
+type NewPort = 'lisp' | 'perl' | 'erlang' | 'ocaml' | 'haskell' | 'clojure' | 'raku'
 
 const recording = (port: string): CoreRecording => JSON.parse(readFileSync(new URL(`../src/data/core-recordings/${port}.json`, import.meta.url), 'utf8'))
 const capabilityOf = (port: string) => recording(port).capabilities['typed-graph']!
@@ -163,8 +164,8 @@ describe('the player of a program that connects to a server its setup started',
 })
 
 describe('the real player component for each new port', () => {
-  const names = { lisp: 'Common Lisp', perl: 'Perl', erlang: 'Erlang', ocaml: 'OCaml', haskell: 'Haskell', clojure: 'Clojure' } as const
-  it.each(['lisp', 'perl', 'erlang', 'ocaml', 'haskell', 'clojure'] as const)('draws %s: a frame and a result for the state before the first call and for each call, and plans each view', async (port) => {
+  const names = { lisp: 'Common Lisp', perl: 'Perl', erlang: 'Erlang', ocaml: 'OCaml', haskell: 'Haskell', clojure: 'Clojure', raku: 'Raku' } as const
+  it.each(['lisp', 'perl', 'erlang', 'ocaml', 'haskell', 'clojure', 'raku'] as const)('draws %s: a frame and a result for the state before the first call and for each call, and plans each view', async (port) => {
     const played = (await playableCapability(port, 'typed-graph', shown(port)))!
     const template = await loadAstroTemplate('components/core/CorePlayer.astro', {
       real: ['components/HomeExample.astro', 'components/replay/TmuxScreen.astro', 'components/replay/ReplayControls.astro'],
@@ -197,7 +198,7 @@ describe('the landing page player of the new ports', () => {
 
   it('replaces the plain example with the player once a port has a sound recording', async () => {
     const render = renderer(await loadAstroTemplate('components/CoreShowcase.astro', { stubs, modules: { 'astro-expressive-code/components': { Code } } }))
-    for (const port of ['lisp', 'erlang', 'perl', 'ocaml', 'haskell', 'clojure']) {
+    for (const port of ['lisp', 'erlang', 'perl', 'ocaml', 'haskell', 'clojure', 'raku']) {
       const document = await render(port)
       expect(document.querySelector('[data-capability-panel="typed-graph"] [data-core-player]'), `${port} plays its recording`).not.toBeNull()
       expect(document.querySelector('[data-home-example]'), `${port} keeps no plain example`).toBeNull()
@@ -671,3 +672,96 @@ describe('the Clojure recording of the landing page program', () => {
     expect(await playableCapability('clojure', 'typed-graph', `${shown('clojure')}\n; edited`)).toBeUndefined()
   })
 })
+
+describe('Raku recipe', () => {
+  const recipe = RAKU['typed-graph']
+  const code = home.raku.files[0]!.code
+  const marked = recipe.instrument(code, recipe.steps)
+
+  it('adds only marker lines to the displayed program: the helper after its import, a mark after each call, and the close mark as a phaser', () => {
+    expect(withoutRakuMarks(marked)).toBe(code)
+    const lines = marked.split('\n')
+    expect(lines[lines.indexOf('use LibTmux;') + 1]).toBe('use JSON::Fast; # docs:mark')
+    const marks = lines.filter((line: string) => line.endsWith('docs:mark') && /docs-mark\("/.test(line)).map((line: string) => /docs-mark\("([^"]+)"/.exec(line)?.[1])
+    expect(marks.toSorted()).toEqual(recipe.steps.map((step: { id: string }) => step.id).toSorted())
+  })
+
+  it('declares the close mark before the program\'s own LEAVE, so that it runs after the daemon has stopped', () => {
+    const lines = marked.split('\n')
+    const mark = lines.findIndex((line: string) => line.startsWith('LEAVE docs-mark("close"'))
+    expect(lines[mark + 1]).toBe('LEAVE $server.close if $server.defined;')
+  })
+
+  it('refuses an anchor the program does not hold, and a program without the import to put the helper after', () => {
+    expect(() => recipe.instrument(code, [{ id: 'x', anchor: '$server.nope(', value: 'Nil' }])).toThrow(/not on exactly one line/)
+    expect(() => recipe.instrument(code.replace('use LibTmux;', ''), recipe.steps)).toThrow(/use LibTmux/)
+  })
+
+  it('finds every call on exactly one line of the displayed program', () => {
+    for (const step of recipe.steps) expect(statementLines(code, step.anchor, syntaxOf('raku'), occurrenceOf(step)), step.id).toBeDefined()
+  })
+
+  it('reads a command out of the guard the library wraps it in, and nothing else', () => {
+    const guarded = ['if-shell', '-F', '#{==:#{pid}/#{start_time},1/2}', '"split-window" "-t" "%0" "--" "exec cat"', `libtmux-stale-${'a'.repeat(32)}`]
+    expect(recipe.unwrap(guarded)).toEqual(['split-window', '-t', '%0', '--', 'exec cat'])
+    expect(recipe.unwrap(['split-window', '-t', '%0'])).toBeUndefined()
+    expect(recipe.unwrap(['if-shell', '-F', 'x', 'y', 'z'])).toBeUndefined()
+  })
+})
+
+describe('the Raku recording of the landing page program', () => {
+  const capability = capabilityOf('raku')
+  const step = (id: string) => capability.steps.find((each) => each.id === id)!
+  const sent = (id: string) => step(id).commands.filter((command) => command.role === 'command').map((command) => command.tmux.split(' ')[0])
+
+  it('is sound, of the displayed program, and was recorded at the revision the page records', () => {
+    expectPlayable('raku')
+  })
+
+  it('has one step per call of the step map, in the order the calls ran', () => {
+    expect(capability.steps.map((each) => [each.id, each.label, each.anchor, each.type])).toEqual(RAKU['typed-graph'].steps.map((each: { id: string; label: string; anchor: string; type: string }) => [each.id, each.label, each.anchor, each.type]))
+  })
+
+  it('starts with no server: Server.start starts the daemon and creates the first session', () => {
+    expect(capability.tmuxBefore.sessions).toEqual([])
+    expect(sent('start')).toEqual(['new-session'])
+  })
+
+  it('records what each call returned and the commands that changed tmux', () => {
+    expect(step('start').returned).toEqual({ socket: 'libtmux-owned-AbC123' })
+    expect(step('snapshot-before').returned).toEqual({ sessions: 1, windows: 1, panes: 1 })
+    expect(step('split').returned).toEqual({ id: '%1' })
+    expect(step('snapshot').returned).toEqual({ sessions: 1, windows: 1, panes: 2 })
+    expect(step('selected').returned).toEqual({ id: '%0', title: 'editor' })
+    expect(sent('split')).toEqual(['split-window'])
+    expect(sent('title-editor')).toEqual(['select-pane'])
+    expect(sent('title-logs')).toEqual(['select-pane'])
+    expect(sent('snapshot-before')).toEqual(['list-sessions', 'list-windows', 'list-windows', 'list-panes', 'list-clients', 'list-sessions', 'list-buffers'])
+    expect(sent('pane'), 'reading a snapshot sends nothing').toEqual([])
+    expect(sent('selected'), 'reading a snapshot sends nothing').toEqual([])
+  })
+
+  it('counts the library\'s daemon identity checks as probes, and shows no guard, token or process id', () => {
+    expect(step('split').commands).toHaveLength(1)
+    expect(step('snapshot').commands.filter((command) => command.role === 'probe').length).toBeGreaterThan(0)
+    const text = JSON.stringify(capability.steps.flatMap((each) => each.commands.map((command) => command.tmux)))
+    expect(text).not.toMatch(/if-shell|libtmux-stale|[0-9a-f]{32}(?<!0{32})/)
+    expect(text).not.toMatch(/libtmux-owned-(?!AbC123)/)
+  })
+
+  it('ends with the call that closes the owned daemon, after which no session is left', () => {
+    const close = step('close')
+    expect(close.stopsServer).toBe(true)
+    expect(close.tmux.sessions).toEqual([])
+    expect(close.returned).toBeNull()
+  })
+
+  it('plays every call in every view of the program, each on the line its anchor names', () => {
+    expectPlayedInEveryView('raku')
+  })
+
+  it('is played for the program it records and for no other', async () => {
+    expect(await playableCapability('raku', 'typed-graph', shown('raku'))).toBeDefined()
+    expect(await playableCapability('raku', 'typed-graph', `${shown('raku')}\n# edited`)).toBeUndefined()
+  })
+})
diff --git a/site/test/deploy-workflow.test.ts b/site/test/deploy-workflow.test.ts
index ee43b66f2..2dc9f9a98 100644
--- a/site/test/deploy-workflow.test.ts
+++ b/site/test/deploy-workflow.test.ts
@@ -12,7 +12,7 @@ const shell = readFileSync(new URL('../../.github/workflows/deploy-shell.yml', i
 const testWorkflow = readFileSync(new URL('../../.github/workflows/test.yml', import.meta.url), 'utf8')
 const publicationAudit = readFileSync(new URL('../../scripts/test-all.sh', import.meta.url), 'utf8')
 const publishRoot = readFileSync(new URL('../../scripts/publish-root.sh', import.meta.url), 'utf8')
-const sourceGuidePorts = ['ruby', 'lua', 'powershell', 'julia', 'elixir', 'ocaml', 'haskell', 'perl', 'lisp', 'erlang']
+const sourceGuidePorts = ['ruby', 'lua', 'powershell', 'julia', 'elixir', 'ocaml', 'haskell', 'perl', 'lisp', 'erlang', 'raku']
 
 function sourceCheckoutContract(workflow: string): void {
   for (const port of sourceGuidePorts) {
diff --git a/site/test/destination-evidence.test.ts b/site/test/destination-evidence.test.ts
index 33526e454..c6ccc9363 100644
--- a/site/test/destination-evidence.test.ts
+++ b/site/test/destination-evidence.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import {
-  EVIDENCE_MAX_AGE_DAYS, REPOSITORY_HOSTS, VERSION_SUPPORT, checkEvidence, collectDestinations, dateProblem, futureRecords, inventoryCoverage, repoOf, staleRecords, staleWarnings,
+  DEVELOPER_VERSION, EVIDENCE_MAX_AGE_DAYS, REPOSITORY_HOSTS, VERSION_SUPPORT, checkEvidence, collectDestinations, dateProblem, futureRecords, inventoryCoverage, repoOf, staleRecords, staleWarnings,
 } from '../../scripts/lib/destination-verification.mjs'
 import evidence from '../src/data/destination-evidence.json'
 import manifests from '../src/data/manifest-packages.json'
@@ -108,6 +108,7 @@ describe('destination evidence', () => {
 
   it('checks the manifest version on every host that lists versions, and says why where one cannot', () => {
     const counts = { confirmed: 0, unsupported: 0 }
+    const developer = (host: string, version?: string) => DEVELOPER_VERSION[host as keyof typeof DEVELOPER_VERSION]?.test(version ?? '') === true
     for (const [url, destination] of wanted) {
       const record = records.get(url)!
       if (!record.ok || !destination.entries.some(({ status }: { status: string }) => status === 'published')) continue
@@ -122,7 +123,8 @@ describe('destination evidence', () => {
         counts.unsupported += 1
       } else {
         expect(versionsOf(url), url).toEqual(destination.expected.map(({ version }: { version: string }) => version))
-        for (const check of checksOf(url)) expect(check.check, url).toBe('confirmed')
+        // A host that never lists developer releases leaves one in a manifest as such, and only that host does.
+        for (const check of checksOf(url)) expect(check.check, url).toBe(developer(destination.host, check.version) ? 'developer' : 'confirmed')
         counts.confirmed += 1
       }
     }
@@ -132,6 +134,45 @@ describe('destination evidence', () => {
     expect(counts.unsupported).toBeGreaterThan(0)
   })
 
+  it('verifies each CPAN package and POD page through MetaCPAN’s API and names the repository it reports', () => {
+    const cpan = evidence.destinations.filter((record) => record.host === 'metacpan')
+    expect(cpan.map((record) => record.url)).toEqual([
+      'https://metacpan.org/dist/LibTmux', 'https://metacpan.org/dist/LibTmux-Async', 'https://metacpan.org/dist/LibTmux-Workspace',
+      'https://metacpan.org/pod/LibTmux', 'https://metacpan.org/pod/LibTmux::Async', 'https://metacpan.org/pod/LibTmux::Workspace',
+    ])
+    for (const record of cpan) {
+      // The page itself answers scripted clients with a challenge, so the record names the API that did the verifying.
+      expect(record, record.url).toMatchObject({ ok: true, status: 200, repository: 'libtmux/libtmux-perl' })
+      expect((record as { requested: string }).requested, record.url).toMatch(/^https:\/\/fastapi\.metacpan\.org\/v1\/(?:release|module)\//)
+      expect(record.identity, record.url).toBe(new URL(record.url).pathname.split('/').pop())
+    }
+    expect(REPOSITORY_HOSTS.has('metacpan')).toBe(true)
+    expect(VERSION_SUPPORT.metacpan).toBe(true)
+  })
+
+  it('takes a developer version from the manifest as no claim of a release, on a CPAN host and nowhere else', () => {
+    const demoEntry = demo({
+      coordinate: 'Demo-Dist', label: 'Demo-Dist', package: { host: 'metacpan', url: 'https://metacpan.org/dist/Demo-Dist' },
+    })
+    const record = (version: string, check: string) => ({
+      url: 'https://metacpan.org/dist/Demo-Dist', kinds: ['package'], host: 'metacpan', ok: true, status: 200, identity: 'Demo-Dist', repository: 'libtmux/libtmux-rs',
+      versionChecks: [{ version, source: 'libtmux/libtmux-rs:Makefile.PL', ports: ['demo'], check }], checkedAt: new Date().toISOString().slice(0, 10), entries: ['demo:demo'],
+    })
+    const declared = (version: string) => ({ ports: { demo: { distributions: [{ name: 'Demo-Dist', version, manifest: 'Makefile.PL', repo: 'libtmux/libtmux-rs' }] } } })
+    const repository = {
+      url: 'https://github.com/libtmux/libtmux-rs', kinds: ['source'], host: 'github', ok: true, status: 200, identity: 'libtmux/libtmux-rs',
+      versionChecks: [{ check: 'unsupported', note: 'a branch link names no release' }], checkedAt: record('0.003', 'confirmed').checkedAt, entries: ['demo:demo'],
+    }
+    const problems = (version: string, check: string) =>
+      checkEvidence(demoEntry, { schema: 1, checkedAt: repository.checkedAt, destinations: [record(version, check), repository] }, { manifests: declared(version), today })
+    expect(problems('0.001_001', 'developer')).toEqual([])
+    expect(problems('0.003', 'confirmed')).toEqual([])
+    // Controls: a release number is not a developer version, and a developer version that was never checked is not a confirmed one.
+    expect(problems('0.003', 'developer')).toEqual([expect.stringMatching(/records 0\.003 as a developer version, which metacpan does not issue/)])
+    expect(problems('0.001_001', 'absent')).toEqual([expect.stringMatching(/does not carry 0\.001_001/)])
+    expect(DEVELOPER_VERSION).not.toHaveProperty('pypi')
+  })
+
   it('checks a Go module against its own tag series and a package against the module that holds it', () => {
     const manifest = (name: string) => manifests.ports.go.distributions.find((entry) => entry.name === name)!.version
     expect(versionsOf('https://pkg.go.dev/github.com/libtmux/libtmux-go/mcp')).toEqual([manifest('github.com/libtmux/libtmux-go/mcp')])
diff --git a/site/test/documentation-navigation.test.ts b/site/test/documentation-navigation.test.ts
index 699e2c769..d3d02f122 100644
--- a/site/test/documentation-navigation.test.ts
+++ b/site/test/documentation-navigation.test.ts
@@ -41,15 +41,15 @@ describe('documentation surface navigation', () => {
     }
   })
 
-  it('builds Julia’s surfaces and badges the library 0.x from its final tag alone', () => {
+  it('builds Julia’s surfaces and badges the library unreleased, whatever its tags say', () => {
     const julia = PORTS.find((port) => port.slug === 'julia')!
     const recorded = REGISTRY.ports.julia!
-    // What the deploy's resolver wrote once v0.1.0 was tagged and General did not carry it.
-    REGISTRY.ports.julia = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }
+    // What the deploy's resolver writes once v0.1.0 is tagged and General does not carry it.
+    REGISTRY.ports.julia = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }
     try {
       const surfaces = buildDocumentationSurfaces('julia', 'latest', menus(julia, 'latest'))
       expect(Object.fromEntries(surfaces.map((surface) => [surface.id, surface.status])))
-        .toEqual({ core: '0.x', mcp: 'concept', workspace: 'concept' })
+        .toEqual({ core: 'unreleased', mcp: 'concept', workspace: 'concept' })
     } finally {
       REGISTRY.ports.julia = recorded
     }
diff --git a/site/test/fixtures/header-links.ts b/site/test/fixtures/header-links.ts
index d5092837b..72446a97a 100644
--- a/site/test/fixtures/header-links.ts
+++ b/site/test/fixtures/header-links.ts
@@ -11,8 +11,8 @@
  * gains or loses a destination changes a row here.
  *
  * Julia, C++ and Haskell publish no package, so each has only a source link.
- * Only Rust, Elixir, Java, Kotlin, Scala and Swift link an API reference of
- * their own; Go's package page is its reference.
+ * Only Rust, Elixir, Java, Kotlin, Perl, Scala and Swift link an API reference
+ * of their own; Go's package page is its reference.
  */
 export type ExpectedAction = readonly [kind: 'source' | 'package' | 'api', label: string, name: string, url: string]
 export type ExpectedRow = readonly [kind: 'source' | 'package' | 'api', label: string, detail: string, url: string, entries: readonly string[]]
@@ -25,6 +25,16 @@ export interface ExpectedLinks {
 }
 
 export const LINKS: Record<string, ExpectedLinks> = {
+  raku: {
+    actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-raku/lib', 'https://github.com/libtmux/libtmux-raku/tree/master/lib'],
+      ['package', 'Raku Land', 'Raku Land: LibTmux package', 'https://raku.land/zef:libtmux/LibTmux']],
+    indexed: true,
+    rows: [
+      ['source', 'LibTmux', 'Raku distribution · lib', 'https://github.com/libtmux/libtmux-raku/tree/master/lib', ['LibTmux']],
+      ['source', 'libtmux-raku', 'libtmux/libtmux-raku', 'https://github.com/libtmux/libtmux-raku', ['repository']],
+      ['package', 'LibTmux', 'Raku distribution · Raku Land', 'https://raku.land/zef:libtmux/LibTmux', ['LibTmux']],
+    ],
+  },
   ocaml: {
     actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-ocaml/lib', 'https://github.com/libtmux/libtmux-ocaml/tree/master/lib']],
     indexed: true,
@@ -38,14 +48,23 @@ export const LINKS: Record<string, ExpectedLinks> = {
     ],
   },
   perl: {
-    actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-perl/packages/core', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/core']],
+    actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-perl/packages/core', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/core'],
+      ['package', 'MetaCPAN', 'MetaCPAN: LibTmux package', 'https://metacpan.org/dist/LibTmux'],
+      ['api', 'MetaCPAN POD', 'MetaCPAN POD: LibTmux API reference', 'https://metacpan.org/pod/LibTmux']],
     indexed: true,
     rows: [
-      ['source', 'LibTmux', 'packages/core', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/core', ['LibTmux']],
-      ['source', 'LibTmux-Async', 'packages/async', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/async', ['LibTmux-Async']],
+      ['source', 'LibTmux', 'distribution · packages/core', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/core', ['LibTmux']],
+      ['source', 'LibTmux-Async', 'distribution · packages/async', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/async', ['LibTmux-Async']],
       ['source', 'libtmux-perl', 'libtmux/libtmux-perl', 'https://github.com/libtmux/libtmux-perl', ['repository']],
-      ['source', 'LibTmux-Workspace', 'packages/workspace', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/workspace', ['LibTmux-Workspace']],
+      ['source', 'LibTmux-Workspace', 'distribution · packages/workspace', 'https://github.com/libtmux/libtmux-perl/tree/master/packages/workspace', ['LibTmux-Workspace']],
       ['source', 'libtmux-workspace', 'command · packages/workspace/bin/libtmux-workspace', 'https://github.com/libtmux/libtmux-perl/blob/master/packages/workspace/bin/libtmux-workspace', ['libtmux-workspace']],
+      ['package', 'LibTmux', 'distribution · MetaCPAN', 'https://metacpan.org/dist/LibTmux', ['LibTmux']],
+      ['package', 'LibTmux-Async', 'distribution · MetaCPAN', 'https://metacpan.org/dist/LibTmux-Async', ['LibTmux-Async']],
+      // The command ships in the workspace distribution, so its page is the distribution's.
+      ['package', 'LibTmux-Workspace', 'distribution · MetaCPAN', 'https://metacpan.org/dist/LibTmux-Workspace', ['LibTmux-Workspace', 'libtmux-workspace']],
+      ['api', 'LibTmux', 'distribution · MetaCPAN POD', 'https://metacpan.org/pod/LibTmux', ['LibTmux']],
+      ['api', 'LibTmux-Async', 'distribution · MetaCPAN POD', 'https://metacpan.org/pod/LibTmux::Async', ['LibTmux-Async']],
+      ['api', 'LibTmux-Workspace', 'distribution · MetaCPAN POD', 'https://metacpan.org/pod/LibTmux::Workspace', ['LibTmux-Workspace']],
     ],
   },
   clojure: {
@@ -58,11 +77,13 @@ export const LINKS: Record<string, ExpectedLinks> = {
     ],
   },
   erlang: {
-    actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-erlang/apps/libtmux_erlang', 'https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang']],
+    actions: [['source', 'GitHub', 'GitHub: libtmux/libtmux-erlang/apps/libtmux_erlang', 'https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang'],
+      ['package', 'Hex', 'Hex: libtmux_erlang package', 'https://hex.pm/packages/libtmux_erlang']],
     indexed: true,
     rows: [
       ['source', 'libtmux_erlang', 'apps/libtmux_erlang', 'https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang', ['libtmux_erlang']],
       ['source', 'libtmux-erlang', 'libtmux/libtmux-erlang', 'https://github.com/libtmux/libtmux-erlang', ['repository']],
+      ['package', 'libtmux_erlang', 'Hex', 'https://hex.pm/packages/libtmux_erlang', ['libtmux_erlang']],
     ],
   },
   py: {
diff --git a/site/test/fixtures/home-examples.json b/site/test/fixtures/home-examples.json
index 3e33fcc9b..8b0463141 100644
--- a/site/test/fixtures/home-examples.json
+++ b/site/test/fixtures/home-examples.json
@@ -1678,8 +1678,8 @@
       "port": "perl",
       "page": "home",
       "sourceRepository": "libtmux/libtmux-perl",
-      "sourceRevision": "36b978c5eb6aa33873229046037e7d26136ca2cf",
-      "sourceTree": "269782d0ba1403af082abe05736ade4e31b5aa53",
+      "sourceRevision": "a1cab0324b600a5df6e34b92590b5c3bd8f79c69",
+      "sourceTree": "ce5106dc71b51d688816194599e27a62db5a10e2",
       "files": [
         {
           "name": "examples/quickstart.pl",
@@ -1688,14 +1688,16 @@
         },
         {
           "name": "scripts/lib/LibTmuxFixture.pm",
-          "sha256": "6b17d71a3bb2251d7512d5872bc60791fb0f4b1c0557a6d47e6799aaeabed94e",
-          "clipboardSha256": "50c57a617a04dfe553cbbcfd726f1f6a24e8e8cb77ca171aec86cd0f534f3667"
+          "sha256": "234be617ad56c89e3a41c97c8ce84ec1b198a444e06dea9950d0da54f07f3fd6",
+          "clipboardSha256": "6caf21d81a772ac1f567e77b641e04c430906da2b896844961db2a4237ff08b8"
         }
       ],
       "shellRecipe": [
+        "cpm install \\\n    --global \\\n    'LibTmux~>= 0.003'",
         "perl examples/quickstart.pl"
       ],
       "expectedOutputs": [
+        [],
         [
           "session demo",
           "  window 0:editor: %0 %1",
@@ -1728,8 +1730,8 @@
             },
             {
               "name": "scripts/lib/LibTmuxFixture.pm",
-              "sha256": "6b17d71a3bb2251d7512d5872bc60791fb0f4b1c0557a6d47e6799aaeabed94e",
-              "clipboardSha256": "50c57a617a04dfe553cbbcfd726f1f6a24e8e8cb77ca171aec86cd0f534f3667"
+              "sha256": "234be617ad56c89e3a41c97c8ce84ec1b198a444e06dea9950d0da54f07f3fd6",
+              "clipboardSha256": "6caf21d81a772ac1f567e77b641e04c430906da2b896844961db2a4237ff08b8"
             }
           ],
           "excerptSha256": "0f56b6c69c9f65059b161e876346d5c164fd2463371f00fb5cf1df23de43936e"
@@ -1743,8 +1745,8 @@
             },
             {
               "name": "scripts/lib/LibTmuxFixture.pm",
-              "sha256": "6b17d71a3bb2251d7512d5872bc60791fb0f4b1c0557a6d47e6799aaeabed94e",
-              "clipboardSha256": "50c57a617a04dfe553cbbcfd726f1f6a24e8e8cb77ca171aec86cd0f534f3667"
+              "sha256": "234be617ad56c89e3a41c97c8ce84ec1b198a444e06dea9950d0da54f07f3fd6",
+              "clipboardSha256": "6caf21d81a772ac1f567e77b641e04c430906da2b896844961db2a4237ff08b8"
             }
           ],
           "excerptSha256": "1b06fe564ac4ab43baac37aeb5473fe3a5434c1d3bc78c4c5e9570910b463fc6"
@@ -1758,8 +1760,8 @@
             },
             {
               "name": "scripts/lib/LibTmuxFixture.pm",
-              "sha256": "6b17d71a3bb2251d7512d5872bc60791fb0f4b1c0557a6d47e6799aaeabed94e",
-              "clipboardSha256": "50c57a617a04dfe553cbbcfd726f1f6a24e8e8cb77ca171aec86cd0f534f3667"
+              "sha256": "234be617ad56c89e3a41c97c8ce84ec1b198a444e06dea9950d0da54f07f3fd6",
+              "clipboardSha256": "6caf21d81a772ac1f567e77b641e04c430906da2b896844961db2a4237ff08b8"
             }
           ],
           "excerptSha256": "29d2e40a82a47781c8673f3de385a9d106e598dac819a35202c10b1b4205a7dd"
@@ -1918,8 +1920,8 @@
       "port": "erlang",
       "page": "home",
       "sourceRepository": "libtmux/libtmux-erlang",
-      "sourceRevision": "e858027b2b204c3e621b1f74e9419c9b71e3f2f5",
-      "sourceTree": "0e5cf4b98920e44500a7ae8f3be5d8a88fae443f",
+      "sourceRevision": "539c7297ceae65a1cf683e0836eae0a1ccd34d64",
+      "sourceTree": "418f84b74d1be2f7e961d7392a5d66e8e0c47e6d",
       "files": [
         {
           "name": "src/readme_demo.erl",
@@ -1928,8 +1930,8 @@
         },
         {
           "name": "rebar.config",
-          "sha256": "bf5c066734476ae773ef8472e8db6cab88cff06a67ea8f748ed3e42095344540",
-          "clipboardSha256": "99c327669ed758d04d0801dcc672ee528f4dfaaed236fbe6c46a271f5e4ccba0"
+          "sha256": "429086e6932b1fef7329d70c037111f8c636ecd8b002177ed64b29787adf11bd",
+          "clipboardSha256": "d53ea24777d588d02815e45546629a38bf7b197001f5cc08c38907c2221c2703"
         },
         {
           "name": "src/tmux_example.app.src",
@@ -1940,7 +1942,7 @@
       "excerptSha256": "d4ab3b8b2e95bc65ef69eac865a5d198fe79d7ad168a9e649ba234fed5573541",
       "shellRecipe": [
         "rebar3 compile",
-        "env \\\n    -u TMUX \\\n    -u TMUX_PANE \\\n    erl \\\n    -noshell \\\n    -pa _build/default/lib/tmux_example/ebin \\\n    -pa _build/default/lib/libtmux_erlang/apps/libtmux_erlang/ebin \\\n    -eval '\n        {ok, _} = application:ensure_all_started(libtmux_erlang),\n        Tmux = unicode:characters_to_binary(os:find_executable(\"tmux\")),\n        Stats = readme_demo:run(Tmux),\n        io:format(\"~B session, ~B windows, ~B panes; ~B matches~n\", [\n            maps:get(sessions, Stats), maps:get(windows, Stats),\n            maps:get(panes, Stats), maps:get(matched_panes, Stats)]),\n        halt().'"
+        "env \\\n    -u TMUX \\\n    -u TMUX_PANE \\\n    erl \\\n    -noshell \\\n    -pa _build/default/lib/tmux_example/ebin \\\n    -pa _build/default/lib/libtmux_erlang/ebin \\\n    -eval '\n        {ok, _} = application:ensure_all_started(libtmux_erlang),\n        Tmux = unicode:characters_to_binary(os:find_executable(\"tmux\")),\n        Stats = readme_demo:run(Tmux),\n        io:format(\"~B session, ~B windows, ~B panes; ~B matches~n\", [\n            maps:get(sessions, Stats), maps:get(windows, Stats),\n            maps:get(panes, Stats), maps:get(matched_panes, Stats)]),\n        halt().'"
       ],
       "expectedOutputs": [
         [],
@@ -1949,7 +1951,7 @@
         ]
       ],
       "tmuxVersions": [
-        "3.3",
+        "3.3a",
         "3.8"
       ],
       "variants": {
@@ -1962,8 +1964,8 @@
             },
             {
               "name": "rebar.config",
-              "sha256": "bf5c066734476ae773ef8472e8db6cab88cff06a67ea8f748ed3e42095344540",
-              "clipboardSha256": "99c327669ed758d04d0801dcc672ee528f4dfaaed236fbe6c46a271f5e4ccba0"
+              "sha256": "429086e6932b1fef7329d70c037111f8c636ecd8b002177ed64b29787adf11bd",
+              "clipboardSha256": "d53ea24777d588d02815e45546629a38bf7b197001f5cc08c38907c2221c2703"
             },
             {
               "name": "src/tmux_example.app.src",
@@ -1982,8 +1984,8 @@
             },
             {
               "name": "rebar.config",
-              "sha256": "bf5c066734476ae773ef8472e8db6cab88cff06a67ea8f748ed3e42095344540",
-              "clipboardSha256": "99c327669ed758d04d0801dcc672ee528f4dfaaed236fbe6c46a271f5e4ccba0"
+              "sha256": "429086e6932b1fef7329d70c037111f8c636ecd8b002177ed64b29787adf11bd",
+              "clipboardSha256": "d53ea24777d588d02815e45546629a38bf7b197001f5cc08c38907c2221c2703"
             },
             {
               "name": "src/tmux_example.app.src",
@@ -2002,8 +2004,8 @@
             },
             {
               "name": "rebar.config",
-              "sha256": "bf5c066734476ae773ef8472e8db6cab88cff06a67ea8f748ed3e42095344540",
-              "clipboardSha256": "99c327669ed758d04d0801dcc672ee528f4dfaaed236fbe6c46a271f5e4ccba0"
+              "sha256": "429086e6932b1fef7329d70c037111f8c636ecd8b002177ed64b29787adf11bd",
+              "clipboardSha256": "d53ea24777d588d02815e45546629a38bf7b197001f5cc08c38907c2221c2703"
             },
             {
               "name": "src/tmux_example.app.src",
@@ -2014,6 +2016,67 @@
           "excerptSha256": "d4ab3b8b2e95bc65ef69eac865a5d198fe79d7ad168a9e649ba234fed5573541"
         }
       }
+    },
+    {
+      "port": "raku",
+      "page": "home",
+      "sourceRepository": "libtmux/libtmux-raku",
+      "sourceRevision": "9a9838047f1585c2c790b011cb708670999b7bdd",
+      "sourceTree": "8e2aec2ca4319d834066c1ef7fbea50eaa60e998",
+      "shellRecipe": [
+        "zef install 'LibTmux:ver<0.0.1+>:auth<zef:libtmux>'",
+        "raku quickstart.raku"
+      ],
+      "expectedOutputs": [
+        [],
+        [
+          "editor: 2 panes"
+        ]
+      ],
+      "files": [
+        {
+          "name": "quickstart.raku",
+          "sha256": "4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5",
+          "clipboardSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+        }
+      ],
+      "excerptSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a",
+      "tmuxVersions": [
+        "3.3a",
+        "3.8"
+      ],
+      "variants": {
+        "concise": {
+          "files": [
+            {
+              "name": "quickstart.raku",
+              "sha256": "4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5",
+              "clipboardSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+            }
+          ],
+          "excerptSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+        },
+        "errors": {
+          "files": [
+            {
+              "name": "quickstart.raku",
+              "sha256": "4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5",
+              "clipboardSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+            }
+          ],
+          "excerptSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+        },
+        "cleanup": {
+          "files": [
+            {
+              "name": "quickstart.raku",
+              "sha256": "4d017243bab685e717452f47fea56a7f3d039e3a290d9ab61b4acc4a759e04b5",
+              "clipboardSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+            }
+          ],
+          "excerptSha256": "96b3190feb053fd623b46ff1314d8e3ea8a53e51d94bc0bd6a45518c9bee465a"
+        }
+      }
     }
   ]
 }
diff --git a/site/test/fixtures/port-destinations.ts b/site/test/fixtures/port-destinations.ts
index ff0ae5851..ec076002a 100644
--- a/site/test/fixtures/port-destinations.ts
+++ b/site/test/fixtures/port-destinations.ts
@@ -20,11 +20,17 @@ export interface ExpectedDestinations {
 const github = (url: string, name: string): ExpectedLink => ({ url, label: `${name} on GitHub` })
 
 export const DESTINATIONS: Record<string, ExpectedDestinations> = {
+  raku: {
+    source: github('https://github.com/libtmux/libtmux-raku/tree/master/lib', 'libtmux-raku/lib'),
+    registry: { name: 'Raku Land', url: 'https://raku.land/zef:libtmux/LibTmux', icon: 'raku-land', label: 'LibTmux on Raku Land' },
+  },
   ocaml: {
     source: github('https://github.com/libtmux/libtmux-ocaml/tree/master/lib', 'libtmux-ocaml/lib'),
   },
   perl: {
     source: github('https://github.com/libtmux/libtmux-perl/tree/master/packages/core', 'libtmux-perl'),
+    registry: { name: 'MetaCPAN', url: 'https://metacpan.org/dist/LibTmux', icon: 'cpan', label: 'LibTmux on MetaCPAN' },
+    api: { name: 'MetaCPAN POD', url: 'https://metacpan.org/pod/LibTmux', label: 'LibTmux API reference on MetaCPAN POD' },
   },
   clojure: {
     source: github('https://github.com/libtmux/libtmux-java/tree/master/libtmux-clojure', 'libtmux-java/libtmux-clojure'),
@@ -50,6 +56,7 @@ export const DESTINATIONS: Record<string, ExpectedDestinations> = {
   },
   erlang: {
     source: github('https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang', 'libtmux-erlang/apps/libtmux_erlang'),
+    registry: { name: 'Hex', url: 'https://hex.pm/packages/libtmux_erlang', icon: 'hex', label: 'libtmux_erlang on Hex' },
   },
   elixir: {
     source: github('https://github.com/libtmux/libtmux-elixir/tree/main/lib', 'libtmux-elixir/lib'),
diff --git a/site/test/fixtures/port-links.json b/site/test/fixtures/port-links.json
index 7f9c0f7fb..b03fabdd1 100644
--- a/site/test/fixtures/port-links.json
+++ b/site/test/fixtures/port-links.json
@@ -9,8 +9,8 @@
   "powershell v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"PowerShell package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-powershell/tree/a1b2c3d4e5f6/src/LibTmux.PowerShell\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-powershell</span>\n  </a>\n  <a class=\"port-link\" href=\"https://www.powershellgallery.com/packages/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"powershell\" data-decorative=\"true\"></i>\n        <span>PowerShell Gallery</span>\n      </a>\n  \n</nav>",
   "julia": "<nav class=\"port-links mt-3\" aria-label=\"Julia package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-julia/tree/master/src\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-julia</span>\n  </a>\n  \n  \n</nav>",
   "julia v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Julia package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-julia/tree/a1b2c3d4e5f6/src\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-julia</span>\n  </a>\n  \n  \n</nav>",
-  "erlang": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  \n  \n</nav>",
-  "erlang v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/a1b2c3d4e5f6/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  \n  \n</nav>",
+  "erlang": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux_erlang\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  \n</nav>",
+  "erlang v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/a1b2c3d4e5f6/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux_erlang\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  \n</nav>",
   "elixir": "<nav class=\"port-links mt-3\" aria-label=\"Elixir package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-elixir/tree/main/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-elixir</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  <a class=\"port-link\" href=\"https://libtmux.hexdocs.pm/\" rel=\"noopener\">\n        <span>HexDocs</span>\n      </a>\n</nav>",
   "elixir v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Elixir package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-elixir/tree/a1b2c3d4e5f6/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-elixir</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  <a class=\"port-link\" href=\"https://libtmux.hexdocs.pm/\" rel=\"noopener\">\n        <span>HexDocs</span>\n      </a>\n</nav>",
   "haskell": "<nav class=\"port-links mt-3\" aria-label=\"Haskell package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-haskell/tree/master/src\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-haskell</span>\n  </a>\n  \n  \n</nav>",
@@ -41,8 +41,10 @@
   "swift v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Swift package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-swift\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-swift</span>\n  </a>\n  <a class=\"port-link\" href=\"https://swiftpackageindex.com/libtmux/libtmux-swift\" rel=\"noopener\">\n        <i data-icon=\"swift\" data-decorative=\"true\"></i>\n        <span>Swift Package Index</span>\n      </a>\n  \n</nav>",
   "ocaml": "<nav class=\"port-links mt-3\" aria-label=\"OCaml package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-ocaml/tree/master/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-ocaml</span>\n  </a>\n  \n  \n</nav>",
   "ocaml v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"OCaml package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-ocaml/tree/a1b2c3d4e5f6/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-ocaml</span>\n  </a>\n  \n  \n</nav>",
-  "perl": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/master/packages/core\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-perl</span>\n  </a>\n  \n  \n</nav>",
-  "perl v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/a1b2c3d4e5f6/packages/core\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-perl</span>\n  </a>\n  \n  \n</nav>",
+  "perl": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/master/packages/core\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-perl</span>\n  </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/dist/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"cpan\" data-decorative=\"true\"></i>\n        <span>MetaCPAN</span>\n      </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/pod/LibTmux\" rel=\"noopener\">\n        <span>MetaCPAN POD</span>\n      </a>\n</nav>",
+  "perl v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/a1b2c3d4e5f6/packages/core\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-perl</span>\n  </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/dist/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"cpan\" data-decorative=\"true\"></i>\n        <span>MetaCPAN</span>\n      </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/pod/LibTmux\" rel=\"noopener\">\n        <span>MetaCPAN POD</span>\n      </a>\n</nav>",
+  "raku": "<nav class=\"port-links mt-3\" aria-label=\"Raku package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-raku/tree/master/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-raku</span>\n  </a>\n  <a class=\"port-link\" href=\"https://raku.land/zef:libtmux/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"raku-land\" data-decorative=\"true\"></i>\n        <span>Raku Land</span>\n      </a>\n  \n</nav>",
+  "raku v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Raku package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-raku/tree/a1b2c3d4e5f6/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-raku</span>\n  </a>\n  <a class=\"port-link\" href=\"https://raku.land/zef:libtmux/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"raku-land\" data-decorative=\"true\"></i>\n        <span>Raku Land</span>\n      </a>\n  \n</nav>",
   "powershell v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"PowerShell package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-powershell/tree/v1.2.3/src/LibTmux.PowerShell\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-powershell</span>\n  </a>\n  <a class=\"port-link\" href=\"https://www.powershellgallery.com/packages/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"powershell\" data-decorative=\"true\"></i>\n        <span>PowerShell Gallery</span>\n      </a>\n  \n</nav>",
   "powershell next": "<nav class=\"port-links mt-3\" aria-label=\"PowerShell package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-powershell/tree/master/src/LibTmux.PowerShell\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-powershell</span>\n  </a>\n  <a class=\"port-link\" href=\"https://www.powershellgallery.com/packages/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"powershell\" data-decorative=\"true\"></i>\n        <span>PowerShell Gallery</span>\n      </a>\n  \n</nav>",
   "powershell latest @revision": "<nav class=\"port-links mt-3\" aria-label=\"PowerShell package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-powershell/tree/a1b2c3d4e5f6/src/LibTmux.PowerShell\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-powershell</span>\n  </a>\n  <a class=\"port-link\" href=\"https://www.powershellgallery.com/packages/LibTmux\" rel=\"noopener\">\n        <i data-icon=\"powershell\" data-decorative=\"true\"></i>\n        <span>PowerShell Gallery</span>\n      </a>\n  \n</nav>",
@@ -52,9 +54,9 @@
   "elixir v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"Elixir package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-elixir/tree/v1.2.3/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-elixir</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  <a class=\"port-link\" href=\"https://libtmux.hexdocs.pm/\" rel=\"noopener\">\n        <span>HexDocs</span>\n      </a>\n</nav>",
   "elixir next": "<nav class=\"port-links mt-3\" aria-label=\"Elixir package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-elixir/tree/main/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-elixir</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  <a class=\"port-link\" href=\"https://libtmux.hexdocs.pm/\" rel=\"noopener\">\n        <span>HexDocs</span>\n      </a>\n</nav>",
   "elixir latest @revision": "<nav class=\"port-links mt-3\" aria-label=\"Elixir package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-elixir/tree/a1b2c3d4e5f6/lib\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-elixir</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  <a class=\"port-link\" href=\"https://libtmux.hexdocs.pm/\" rel=\"noopener\">\n        <span>HexDocs</span>\n      </a>\n</nav>",
-  "erlang v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/v1.2.3/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  \n  \n</nav>",
-  "erlang next": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  \n  \n</nav>",
-  "erlang latest @revision": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/a1b2c3d4e5f6/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  \n  \n</nav>",
+  "erlang v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/v1.2.3/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux_erlang\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  \n</nav>",
+  "erlang next": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/master/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux_erlang\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  \n</nav>",
+  "erlang latest @revision": "<nav class=\"port-links mt-3\" aria-label=\"Erlang package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-erlang/tree/a1b2c3d4e5f6/apps/libtmux_erlang\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-erlang</span>\n  </a>\n  <a class=\"port-link\" href=\"https://hex.pm/packages/libtmux_erlang\" rel=\"noopener\">\n        <i data-icon=\"hex\" data-decorative=\"true\"></i>\n        <span>Hex</span>\n      </a>\n  \n</nav>",
   "kotlin v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"Kotlin package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-java/tree/v1.2.3/libtmux-kotlin\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-java</span>\n  </a>\n  <a class=\"port-link\" href=\"https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <i data-icon=\"maven\" data-decorative=\"true\"></i>\n        <span>Maven Central</span>\n      </a>\n  <a class=\"port-link\" href=\"https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <span>Dokka</span>\n      </a>\n</nav>",
   "kotlin next": "<nav class=\"port-links mt-3\" aria-label=\"Kotlin package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-java/tree/master/libtmux-kotlin\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-java</span>\n  </a>\n  <a class=\"port-link\" href=\"https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <i data-icon=\"maven\" data-decorative=\"true\"></i>\n        <span>Maven Central</span>\n      </a>\n  <a class=\"port-link\" href=\"https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <span>Dokka</span>\n      </a>\n</nav>",
   "kotlin latest @revision": "<nav class=\"port-links mt-3\" aria-label=\"Kotlin package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-java/tree/a1b2c3d4e5f6/libtmux-kotlin\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>libtmux/libtmux-java</span>\n  </a>\n  <a class=\"port-link\" href=\"https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <i data-icon=\"maven\" data-decorative=\"true\"></i>\n        <span>Maven Central</span>\n      </a>\n  <a class=\"port-link\" href=\"https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin\" rel=\"noopener\">\n        <span>Dokka</span>\n      </a>\n</nav>",
@@ -110,8 +112,8 @@
   "swift workspace v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Swift package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-swift/tree/v1.2.3/Sources/TmuxWorkspaceCLI\" title=\"libtmux/libtmux-swift/Sources/TmuxWorkspaceCLI (v1.2.3)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  <a class=\"port-link\" href=\"https://swiftpackageindex.com/libtmux/libtmux-swift\" rel=\"noopener\">\n        <i data-icon=\"swift\" data-decorative=\"true\"></i>\n        <span>Swift Package Index</span>\n      </a>\n  \n</nav>",
   "ocaml workspace": "<nav class=\"port-links mt-3\" aria-label=\"OCaml package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-ocaml/tree/master/cli\" title=\"libtmux/libtmux-ocaml/cli (master)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  \n  \n</nav>",
   "ocaml workspace v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"OCaml package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-ocaml/tree/v1.2.3/cli\" title=\"libtmux/libtmux-ocaml/cli (v1.2.3)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  \n  \n</nav>",
-  "perl workspace": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/master/packages/workspace\" title=\"libtmux/libtmux-perl/packages/workspace (master)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  \n  \n</nav>",
-  "perl workspace v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/v1.2.3/packages/workspace\" title=\"libtmux/libtmux-perl/packages/workspace (v1.2.3)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  \n  \n</nav>",
+  "perl workspace": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/master/packages/workspace\" title=\"libtmux/libtmux-perl/packages/workspace (master)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/dist/LibTmux-Workspace\" rel=\"noopener\">\n        <i data-icon=\"cpan\" data-decorative=\"true\"></i>\n        <span>MetaCPAN</span>\n      </a>\n  \n</nav>",
+  "perl workspace v1.2.3 @revision": "<nav class=\"port-links mt-3\" aria-label=\"Perl package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-perl/tree/v1.2.3/packages/workspace\" title=\"libtmux/libtmux-perl/packages/workspace (v1.2.3)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  <a class=\"port-link\" href=\"https://metacpan.org/dist/LibTmux-Workspace\" rel=\"noopener\">\n        <i data-icon=\"cpan\" data-decorative=\"true\"></i>\n        <span>MetaCPAN</span>\n      </a>\n  \n</nav>",
   "ts mcp v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"TypeScript package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-ts/tree/v1.2.3/packages/mcp\" title=\"libtmux/libtmux-ts/packages/mcp (v1.2.3)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  <a class=\"port-link\" href=\"https://www.npmjs.com/package/@libtmux/mcp\" rel=\"noopener\">\n        <i data-icon=\"npm\" data-decorative=\"true\"></i>\n        <span>npm</span>\n      </a>\n  \n</nav>",
   "py workspace v1.2.3": "<nav class=\"port-links mt-3\" aria-label=\"Python package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/tmux-python/tmuxp/tree/master/src/tmuxp\" title=\"tmux-python/tmuxp/src/tmuxp (master)\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  <a class=\"port-link\" href=\"https://pypi.org/project/tmuxp/\" rel=\"noopener\">\n        <i data-icon=\"pypi\" data-decorative=\"true\"></i>\n        <span>PyPI</span>\n      </a>\n  \n</nav>",
   "kotlin workspace v1.2.3 (no package)": "<nav class=\"port-links mt-3\" aria-label=\"Kotlin package and source\">\n  \n  <a class=\"port-link\" href=\"https://github.com/libtmux/libtmux-java\" rel=\"noopener\">\n    <i data-icon=\"github\" data-decorative=\"true\"></i>\n    <span>GitHub</span>\n  </a>\n  \n  \n</nav>",
diff --git a/site/test/header-link-data.test.ts b/site/test/header-link-data.test.ts
index 6027c4825..7e859e3f6 100644
--- a/site/test/header-link-data.test.ts
+++ b/site/test/header-link-data.test.ts
@@ -55,13 +55,23 @@ describe('header links', () => {
     expect(go.actions[1]!.label).toBe('pkg.go.dev')
     expect(go.actions[1]!.name).toBe('pkg.go.dev: libtmux/libtmux-go/tmux package and API reference')
     // Control: a port whose reference is another page names only its package, and has the reference chip as well.
-    for (const slug of ['rs', 'java', 'swift', 'elixir']) {
+    for (const slug of ['rs', 'java', 'swift', 'elixir', 'perl']) {
       const [, pack, api] = links(slug).actions
       expect(pack!.name, slug).toMatch(/ package$/)
       expect(api?.kind, slug).toBe('api')
     }
   })
 
+  it('finds each Perl distribution, module and the command by the words a reader types', () => {
+    expect(found('perl', 'cpan')).toEqual(found('perl', 'metacpan'))
+    expect(found('perl', 'metacpan')).toEqual(['package:LibTmux', 'package:LibTmux-Async', 'package:LibTmux-Workspace', 'api:LibTmux', 'api:LibTmux-Async', 'api:LibTmux-Workspace'])
+    expect(found('perl', 'pod async')).toEqual(['api:LibTmux-Async'])
+    expect(found('perl', 'distribution workspace registry')).toEqual(['package:LibTmux-Workspace'])
+    // The command ships in the workspace distribution, so its search finds that distribution's page.
+    expect(found('perl', 'libtmux-workspace registry')).toEqual(['package:LibTmux-Workspace'])
+    expect(found('perl', 'LibTmux::Async::Server')).toEqual(['source:LibTmux-Async', 'package:LibTmux-Async', 'api:LibTmux-Async'])
+  })
+
   it('names one row for each URL and keeps every entry’s identity in its search text', () => {
     for (const port of PORTS) {
       const urls = links(port.slug).rows.map((row) => row.url)
@@ -196,8 +206,10 @@ describe('header links', () => {
     expect(marks('java')).toEqual(['github', 'maven', 'javadoc'])
     expect(marks('rs')).toEqual(['github', 'crates', 'docsrs'])
     expect(marks('elixir')).toEqual(['github', 'hex', 'hexdocs'])
+    // MetaCPAN serves the distribution page and its POD, so the two chips wear different marks.
+    expect(marks('perl')).toEqual(['github', 'cpan', 'pod'])
     // Control: every reference chip wears a mark of the reference, not of the package host it follows.
-    for (const slug of ['rs', 'java', 'kotlin', 'scala', 'swift', 'elixir']) {
+    for (const slug of ['rs', 'java', 'kotlin', 'scala', 'swift', 'elixir', 'perl']) {
       const [, pack, api] = links(slug).actions
       expect(api!.icon, slug).not.toBe(pack!.icon)
     }
diff --git a/site/test/native-name.test.ts b/site/test/native-name.test.ts
index 68e300871..5989bb2bb 100644
--- a/site/test/native-name.test.ts
+++ b/site/test/native-name.test.ts
@@ -202,7 +202,7 @@ describe('short names', () => {
   })
 
   it('follow native ownership and qualification for every symbol of every port', { timeout: 30_000 }, () => {
-    const separators: Record<string, string[]> = { perl: ['::'], rs: ['::'], cxx: ['::'], ruby: ['::', '.', '#'], lua: ['.', ':'], lisp: [':'], powershell: ['\\'], clojure: ['/'], erlang: [':', '.'] }
+    const separators: Record<string, string[]> = { perl: ['::'], rs: ['::'], cxx: ['::'], ruby: ['::', '.', '#'], lua: ['.', ':'], lisp: [':'], raku: ['::', '.'], powershell: ['\\'], clojure: ['/'], erlang: [':', '.'] }
     for (const [port, model] of Object.entries(API_MODELS)) {
       const owners = new Map(model.symbols.map((symbol) => [symbol.id, symbol]))
       for (const symbol of model.symbols) {
@@ -216,6 +216,7 @@ describe('short names', () => {
           expect(shown, symbol.id).toBe(`#${owner.name}:${symbol.name.slice(1)}`)
           continue
         }
+        if (port === 'raku' && !symbol.id.startsWith(owner.id)) { expect(shown, symbol.id).toBe(symbol.id); continue }
         expect(shown.startsWith(owner.name) && shown.endsWith(symbol.name), `${port} ${symbol.id}`).toBe(true)
         const separator = shown.slice(owner.name.length, shown.length - symbol.name.length)
         // A Rust tuple field follows its owner with a dot, as rustdoc writes it; every other Rust member with `::`.
diff --git a/site/test/package-destinations.test.ts b/site/test/package-destinations.test.ts
new file mode 100644
index 000000000..8abd6d19e
--- /dev/null
+++ b/site/test/package-destinations.test.ts
@@ -0,0 +1,172 @@
+import { describe, expect, it } from 'vitest'
+import evidence from '../src/data/destination-evidence.json'
+import { portHeaderLinks } from '../src/lib/header-links'
+import { INVENTORY } from '../src/lib/port-inventory'
+import { PORT_BY_SLUG, PORTS, installCommand, portDestinations, productStatus, productStatusLine, releaseMaturity } from '../src/lib/ports'
+import { REGISTRY, installsFor, registryFor } from '../src/lib/registry'
+
+/**
+ * Where each package's registry destination and install command come from.
+ *
+ * A package with no registry release gets no registry link, no registry
+ * install and no `published` status; its source install is the only install.
+ * The registry's answer for each is recorded in `scripts/gen-registry.mjs`
+ * and `destination-evidence.json`; these tests hold the site's own tables to it.
+ */
+
+/**
+ * Per port with no registry release: the spelling that would resolve its
+ * package from the ecosystem's registry, and what every install must name instead.
+ */
+const SOURCE_ONLY: Record<string, { registryInstall: RegExp; source?: string }> = {
+  julia: { registryInstall: /Pkg\.add\("LibTmux"\)|PackageSpec\(name=/, source: 'libtmux/libtmux-julia.git' },
+  ocaml: { registryInstall: /\bopam\s+(?:install|pin\s+add)\s+libtmux/ },
+  haskell: { registryInstall: /^build-depends:|cabal\s+install\s+libtmux/m, source: 'libtmux/libtmux-haskell' },
+  lisp: { registryInstall: /ql:quickload|ros\s+install|qlot\s+add\s+libtmux/ },
+}
+
+/** Every command a reader or a prompt can be handed for a port's core package. */
+const coreInstalls = (slug: string) => {
+  const port = PORT_BY_SLUG[slug]!
+  return [...port.installs.map(({ label, code }) => [`installs ${label}`, code] as const),
+    ...Object.entries(port.installForms).map(([form, { code }]) => [`installForms.${form}`, code] as const)]
+}
+
+describe.each(Object.keys(SOURCE_ONLY))('%s, which no registry carries', (slug) => {
+  const { registryInstall, source } = SOURCE_ONLY[slug]!
+
+  it('offers no registry install in any form', () => {
+    for (const [where, code] of coreInstalls(slug)) expect(code, where).not.toMatch(registryInstall)
+  })
+
+  it.skipIf(!source)('names its source in every install form', () => {
+    for (const [where, code] of coreInstalls(slug)) expect(code, where).toContain(source!)
+  })
+
+  it('names no registry for the port', () => {
+    expect(PORT_BY_SLUG[slug]!.registry).toBeUndefined()
+    expect(PORT_BY_SLUG[slug]!.ecosystemHost).toBeUndefined()
+  })
+
+  it('records every package as available from source, never as published', () => {
+    const packages = INVENTORY[slug]!.filter(({ kind }) => kind !== 'source')
+    expect(packages.length).toBeGreaterThan(0)
+    for (const entry of packages) {
+      // A planned entry is declared but not yet in the repository, so it links nothing.
+      expect(['configured-unpublished', 'planned'], entry.id).toContain(entry.status)
+      if (entry.status === 'configured-unpublished') expect(entry.sourceAvailable, entry.id).toBe(true)
+      expect(entry.note, entry.id).toBeTruthy()
+      expect(entry.package ?? entry.api, entry.id).toBeUndefined()
+    }
+    // The public repository itself is what is published.
+    for (const entry of INVENTORY[slug]!.filter(({ kind }) => kind === 'source')) expect(entry.status, entry.id).toBe('published')
+  })
+
+  it('links only source from the header', () => {
+    const links = portHeaderLinks(PORT_BY_SLUG[slug]!)
+    expect(links.actions.map(({ kind }) => kind)).toEqual(['source'])
+    expect(links.rows.every(({ kind }) => kind === 'source')).toBe(true)
+  })
+})
+
+describe('Julia companions', () => {
+  const julia = PORT_BY_SLUG.julia!
+
+  it('offer only the Git install, with no registry spelling', () => {
+    for (const pkg of julia.packages!) {
+      for (const { label, code } of pkg.installs!) {
+        expect(pkg.registry, pkg.name).toBeUndefined()
+        expect(code, `${pkg.name} ${label}`).toContain('url=repo')
+        expect(code, `${pkg.name} ${label}`).not.toMatch(SOURCE_ONLY.julia!.registryInstall)
+      }
+    }
+  })
+})
+
+describe('Erlang, released on Hex as libtmux_erlang', () => {
+  const erlang = PORT_BY_SLUG.erlang!
+  const hex = 'https://hex.pm/packages/libtmux_erlang'
+  const library = INVENTORY.erlang!.find(({ kind }) => kind === 'library')!
+
+  it('names Hex as the registry', () => {
+    expect(erlang.registry).toEqual({ name: 'Hex', url: hex, icon: 'hex' })
+    expect(portDestinations({ port: erlang }).registry?.url).toBe(hex)
+    expect(registryFor(erlang)).toMatchObject({ status: 'release', release: '0.0.1', tag: 'v0.0.1' })
+  })
+
+  it('links no HexDocs reference, because Hex carries no documentation for the package', () => {
+    expect(erlang.ecosystemHost).toBeUndefined()
+    expect(INVENTORY.erlang!.filter(({ api }) => api)).toEqual([])
+    expect(portHeaderLinks(erlang).actions.map(({ kind }) => kind)).toEqual(['source', 'package'])
+  })
+
+  it('records the library as published on Hex, with a passing record', () => {
+    expect(library).toMatchObject({ status: 'published', coordinate: 'libtmux_erlang', package: { host: 'hex', url: hex } })
+    const record = evidence.destinations.find(({ url }) => url === hex)
+    expect(record).toMatchObject({ ok: true, status: 200, identity: 'libtmux_erlang', repository: 'libtmux/libtmux-erlang' })
+  })
+
+  it('installs the Hex release first and keeps Git as the explicit alternative', () => {
+    const release = '{deps, [{libtmux_erlang, "0.0.1"}]}.'
+    expect(installCommand(erlang, registryFor(erlang)).code).toBe(release)
+    const [hexTab, gitTab, ...rest] = installsFor(erlang)
+    expect(rest).toEqual([])
+    expect(hexTab).toMatchObject({ lang: 'erlang', filename: 'rebar.config', code: release })
+    expect(gitTab!.code).toContain('git_subdir')
+    expect(gitTab!.code).toContain('https://github.com/libtmux/libtmux-erlang.git')
+    expect(erlang.installForms.git.code).toContain('git_subdir')
+    for (const { code, additionalBlocks } of installsFor(erlang)) {
+      expect([code, ...(additionalBlocks ?? []).map((block) => block.code)].join('\n')).not.toMatch(/\{(?:version|revision)\}/)
+    }
+  })
+
+  it('shows the Hex release on the port page, without an Elixir tuple or a range to pin', async () => {
+    const { Window } = await import('happy-dom')
+    const { createComponent, renderTemplate } = await import('astro/runtime/server/index.js')
+    const { loadAstroTemplate, renderAstroTemplate } = await import('./astro-templates')
+    const Code = createComponent((_result: unknown, props: { code: string }) => renderTemplate`<pre>${props.code}</pre>`)
+    const template = await loadAstroTemplate('components/CoreHome.astro', { modules: { 'astro-expressive-code/components': { Code } } })
+    const window = new Window()
+    try {
+      window.document.body.innerHTML = await renderAstroTemplate(template, { props: { port: 'erlang', version: 'latest', cards: [] } })
+      const text = window.document.body.textContent
+      expect(text).toContain('{deps, [{libtmux_erlang, "0.0.1"}]}.')
+      expect(text).not.toContain('{:libtmux_erlang')
+      expect(text).not.toContain('Pin to a range')
+    } finally { await window.happyDOM.abort() }
+  })
+
+  it('no longer says the application is unreleased', () => {
+    for (const { note } of erlang.installs) expect(note).not.toMatch(/unreleased|no Hex package/i)
+    expect(library.note ?? '').not.toMatch(/no Hex release/i)
+  })
+})
+
+describe('release badge of a port no registry carries', () => {
+  const core = (slug: string) => INVENTORY[slug]!.find(({ kind }) => kind === 'library')!
+  const unreleased = PORTS.filter(({ slug }) => core(slug).status !== 'published').map(({ slug }) => slug)
+
+  it('covers the ports whose core package is not published', () => {
+    expect(unreleased.sort()).toEqual(['clojure', 'haskell', 'julia', 'lisp', 'ocaml'])
+  })
+
+  it.each(unreleased)('reads %s as unreleased, whatever its newest git tag says', (slug) => {
+    const port = PORT_BY_SLUG[slug]!
+    expect(productStatus(port, 'core', REGISTRY), slug).toBe('unreleased')
+    expect(releaseMaturity(registryFor(port), port.tagGrammar), slug).toBe('unreleased')
+  })
+
+  it('says nothing is released for those ports, and installs from source', () => {
+    expect(productStatusLine('unreleased')).toBe('Not published yet; install from source.')
+    expect(installCommand(PORT_BY_SLUG.julia!, registryFor(PORT_BY_SLUG.julia!)).code).toContain('libtmux-julia.git')
+  })
+
+  it('leaves Swift and C++ on their tags, which is how SwiftPM and their own vcpkg registry resolve releases', () => {
+    expect(core('swift').status).toBe('published')
+    expect(core('cxx').status).toBe('published')
+    for (const slug of ['swift', 'cxx']) {
+      expect(registryFor(slug).maturity, `${slug} keeps the stage its tag names`).toBeUndefined()
+      expect(productStatus(PORT_BY_SLUG[slug]!, 'core', REGISTRY), slug).not.toBe('unreleased')
+    }
+  })
+})
diff --git a/site/test/perl-pod-links.test.ts b/site/test/perl-pod-links.test.ts
index c027a331b..f3a1e8009 100644
--- a/site/test/perl-pod-links.test.ts
+++ b/site/test/perl-pod-links.test.ts
@@ -1,8 +1,15 @@
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
 import { describe, expect, it } from 'vitest'
+import { API, SCHEMA, observeDistribution, podAnchors, problemsWith } from '../../scripts/lib/perl-pod.mjs'
 import { pageIdentity, judgeLabel } from '../../scripts/lib/api-identities.mjs'
 import { languageProblem } from '../../scripts/lib/api-links.mjs'
 import { apiHostOf } from '../../scripts/lib/api-destinations.mjs'
 import { readPage } from '../../scripts/lib/api-html.mjs'
+import { API_MODELS } from '../src/lib/api-models'
+import { POD_DATA, alternateDocs, podLink, type PodData } from '../src/lib/perl-pod'
+import { PORT_BY_SLUG } from '../src/lib/ports'
+import { loadAstroTemplate, renderAstroTemplate, withoutScope } from './astro-templates'
 
 describe('native Perl POD destinations', () => {
   it.each([
@@ -28,3 +35,230 @@ describe('native Perl POD destinations', () => {
     expect(languageProblem('perl', 'https://docs.python.org/3/library/asyncio.html')).toMatchObject({ failure: 'language' })
   })
 })
+
+describe('MetaCPAN POD links from the Perl reference', () => {
+  const model = API_MODELS.perl!
+  const symbol = (id: string) => model.symbols.find((entry) => entry.id === id)!
+  const link = (id: string, version?: string, pod?: PodData) => podLink(model, symbol(id), version, pod)
+  const edit = (change: (data: any) => void): PodData => {
+    const copy = structuredClone(POD_DATA)
+    change(copy)
+    return copy
+  }
+  const POD = 'https://metacpan.org/pod'
+  const dists = PORT_BY_SLUG.perl!.packages!.map((entry) => entry.name)
+
+  it.each(['LibTmux', 'LibTmux::Filter', 'LibTmux::Server', 'LibTmux::Async', 'LibTmux::Async::Server', 'LibTmux::Workspace'])('links the module page of %s to its POD', (id) => {
+    expect(link(id)).toMatchObject({ kind: 'metacpan-pod', href: `${POD}/${id}`, module: id, section: undefined })
+    expect(link(id)!.label).toMatch(/^MetaCPAN POD/)
+  })
+
+  it('links a method to its section, and keeps the synchronous and asynchronous classes of one name apart', () => {
+    expect(link('LibTmux::Server::new')).toMatchObject({ href: `${POD}/LibTmux::Server#new`, distribution: 'LibTmux', section: 'new' })
+    expect(link('LibTmux::Async::Server::new')).toMatchObject({ href: `${POD}/LibTmux::Async::Server#new`, distribution: 'LibTmux-Async', section: 'new' })
+    for (const name of ['capture_pane', 'batch', 'kill_session']) {
+      const [sync, async] = [link(`LibTmux::Server::${name}`), link(`LibTmux::Async::Server::${name}`)]
+      expect(sync?.href, name).toBe(`${POD}/LibTmux::Server#${name}`)
+      expect(async?.href, name).toBe(`${POD}/LibTmux::Async::Server#${name}`)
+    }
+  })
+
+  it('links an inherited method to the POD of the class that declares it', () => {
+    expect(link('LibTmux::Client::generation')?.href).toBe(`${POD}/LibTmux::Entity#generation`)
+    const selection = model.symbols.find((entry) => entry.inheritedFrom === 'LibTmux::Selection')!
+    expect(podLink(model, selection)?.href).toMatch(new RegExp(`^${POD}/LibTmux::Selection#${selection.name}$`))
+    // The workspace package's exception inherits from core's, so its methods belong to a different distribution.
+    const inherited = model.symbols.find((entry) => entry.kind === 'method' && entry.package === 'LibTmux-Workspace' && entry.inheritedFrom === 'LibTmux::X')
+    if (inherited) expect(podLink(model, inherited)).toMatchObject({ distribution: 'LibTmux', module: 'LibTmux::X' })
+  })
+
+  it('sends exception subclasses to the shared document, with a section where the release gave one', () => {
+    expect(link('LibTmux::X::NoMatch')).toMatchObject({ href: `${POD}/LibTmux::X#NoMatch`, module: 'LibTmux::X' })
+    expect(link('LibTmux::X::NoMatch::message')?.href).toBe(`${POD}/LibTmux::X#message`)
+    // A method a subclass declares has no heading of its own in the shared document, and a heading of the same name may be the base class's.
+    expect(link('LibTmux::X::Creation::created')).toMatchObject({ href: `${POD}/LibTmux::X`, section: undefined })
+    expect(link('LibTmux::X::Creation::created')!.title).not.toContain('section')
+  })
+
+  it('opens a section only where the release’s rendered POD has that fragment', () => {
+    for (const entry of model.symbols) {
+      const found = podLink(model, entry)
+      if (!found) continue
+      const release = POD_DATA.distributions[found.distribution]!
+      expect(release.documents[found.module]?.anchors, entry.id).toEqual(expect.arrayContaining(found.section ? [found.section] : []))
+      expect(found.href, entry.id).toMatch(new RegExp(`^${POD}/${found.module}(?:#${found.section})?$`))
+    }
+  })
+
+  it('derives the modules from the recorded releases, not a list of pages', () => {
+    expect(Object.keys(POD_DATA.distributions).sort()).toEqual([...dists].sort())
+    const modules = new Set(model.symbols.map((entry) => podLink(model, entry)?.module).filter(Boolean))
+    // Every distinct document the model's declarations live in, and none the record does not hold.
+    expect(modules.size).toBeGreaterThan(25)
+    for (const module of modules) expect(Object.values(POD_DATA.distributions).some((release) => module! in release.documents), module).toBe(true)
+    // A document the release carries and the model does not declare is not linked.
+    expect(Object.values(POD_DATA.distributions).flatMap((release) => Object.keys(release.documents)).length).toBeGreaterThanOrEqual(modules.size)
+  })
+
+  it('links no declaration the release does not carry or document', () => {
+    // A distribution CPAN has no release of, and a module the release does not list.
+    expect(link('LibTmux::Server', 'latest', edit((data) => { delete data.distributions.LibTmux }))).toBeUndefined()
+    const filterless = edit((data) => { delete data.distributions.LibTmux.documents['LibTmux::Filter']; data.distributions.LibTmux.packages['LibTmux::Filter'] = null })
+    expect(link('LibTmux::Filter', 'latest', filterless)).toBeUndefined()
+    expect(model.symbols.filter((entry) => entry.parent === 'LibTmux::Filter' && !entry.inheritedFrom).map((entry) => podLink(model, entry, 'latest', filterless))).not.toContain(expect.anything())
+    // A package whose POD lives in another file than the one the page documents.
+    expect(link('LibTmux::Server', 'latest', edit((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].path = 'lib/LibTmux/Other.pm' }))).toBeUndefined()
+    // Another port has no alternate documentation here.
+    const rust = API_MODELS.rs!
+    expect(rust.symbols.map((entry) => alternateDocs(rust, entry)).filter(Boolean)).toEqual([])
+  })
+
+  it('falls back to the module page for a method with no section, but only where the file is the release’s own', () => {
+    const headless = (sha?: string) => edit((data) => {
+      const document = data.distributions.LibTmux.documents['LibTmux::Server']
+      document.anchors = document.anchors.filter((id: string) => id !== 'capture_pane')
+      if (sha) document.sha256 = sha
+    })
+    // The file is what the release shipped, so the method exists there even though the POD has no heading for it.
+    expect(link('LibTmux::Server::capture_pane', 'latest', headless())).toMatchObject({ href: `${POD}/LibTmux::Server`, section: undefined, differs: false })
+    // The file has changed since, so a method with no heading may be one the release lacks.
+    expect(link('LibTmux::Server::capture_pane', 'latest', headless('0'.repeat(64)))).toBeUndefined()
+    expect(link('LibTmux::Server::new', 'latest', headless('0'.repeat(64)))?.href).toBe(`${POD}/LibTmux::Server#new`)
+    // A heading the renderer repeated is ambiguous, so it names no section.
+    const repeated = edit((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].anchors.push('new-1') })
+    expect(link('LibTmux::Server::new', 'latest', repeated)).toMatchObject({ href: `${POD}/LibTmux::Server`, section: undefined })
+  })
+
+  it('names the release when the page documents other source than the release shipped', () => {
+    const release = POD_DATA.distributions.LibTmux!.release
+    const changed = edit((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].sha256 = 'f'.repeat(64) })
+    const same = link('LibTmux::Server::new')!
+    expect(same).toMatchObject({ differs: false, label: 'MetaCPAN POD', release })
+    expect(same.title).toBe(`MetaCPAN POD: LibTmux::Server, section new, in LibTmux ${release}`)
+    const other = link('LibTmux::Server::new', 'latest', changed)!
+    expect(other).toMatchObject({ differs: true, label: `MetaCPAN POD ${release}`, href: same.href })
+    expect(other.title).toBe(`MetaCPAN POD ${release}: LibTmux::Server, section new, in LibTmux ${release}; this page documents other source`)
+    // A decimal version is shown as MetaCPAN spells it.
+    expect(release).toMatch(/^\d+\.\d{3}$/)
+  })
+
+  it('pins a page for a release tag to the recorded release, and leaves trunk and previews on the latest', () => {
+    const { author, release } = POD_DATA.distributions.LibTmux!
+    expect(link('LibTmux::Server::new', 'latest')?.href).toBe(`${POD}/LibTmux::Server#new`)
+    for (const version of ['next', 'pr-42', 'main']) expect(link('LibTmux::Server::new', version)?.href, version).toBe(`${POD}/LibTmux::Server#new`)
+    expect(link('LibTmux::Server::new', `v${release}`)?.href).toBe(`https://metacpan.org/release/${author}/LibTmux-${release}/view/lib/LibTmux/Server.pm#new`)
+    expect(link('LibTmux::Async::Server', `v${release}`)?.href).toBe(`https://metacpan.org/release/${author}/LibTmux-Async-${release}/view/lib/LibTmux/Async/Server.pm`)
+    // A dotted three-part tag is another grammar's, so it does not pin a decimal release.
+    expect(link('LibTmux::Server::new', 'v0.0.3')?.href).toBe(`${POD}/LibTmux::Server#new`)
+  })
+
+  it('holds the recorded releases to a shape a link can be built from', () => {
+    expect(problemsWith(POD_DATA, dists)).toEqual([])
+    expect(POD_DATA.schema).toBe(SCHEMA)
+    // Controls: each defect the reader depends on is named.
+    expect(problemsWith({ ...POD_DATA, schema: 2 }, dists)).toEqual(['schema is 2, expected 1'])
+    expect(problemsWith(edit((data) => { delete data.distributions['LibTmux-Async'] }), dists)).toEqual(['LibTmux-Async has no recorded release'])
+    expect(problemsWith(POD_DATA, [...dists, 'LibTmux-Mcp'])).toEqual(['LibTmux-Mcp has no recorded release'])
+    expect(problemsWith(edit((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].sha256 = 'abc' }), dists)).toEqual(['LibTmux: LibTmux::Server has no SHA-256'])
+    expect(problemsWith(edit((data) => { data.distributions.LibTmux.packages['LibTmux::Server'] = 'LibTmux::Missing' }), dists))
+      .toContain('LibTmux: LibTmux::Server is documented by LibTmux::Missing, which the record lacks')
+    expect(problemsWith(edit((data) => { data.distributions.LibTmux.documents['LibTmux::Server'].anchors.push('new') }), dists)).toEqual(['LibTmux: LibTmux::Server lists its fragments wrongly'])
+    expect(problemsWith(edit((data) => { data.distributions.LibTmux.release = '0.0.3' }), dists)).toEqual(['LibTmux: release "0.0.3" is not a decimal version'])
+  })
+})
+
+describe('reading a release from the MetaCPAN API', () => {
+  const body = (value: unknown) => ({ status: 200, text: JSON.stringify(value), bytes: Buffer.from(JSON.stringify(value)) })
+  const page = (name: string, ids: string[]) => ({ status: 200, bytes: Buffer.alloc(0), text: `<h1 id="NAME">NAME</h1>\n<p>${name} - a demo</p>\n${ids.map((id) => `<h2 id="${id}">${id}</h2>`).join('\n')}` })
+  const source = (text: string) => ({ status: 200, bytes: Buffer.from(text), text })
+  const release = { distribution: 'Demo-Dist', name: 'Demo-Dist-0.004', version: '0.004', status: 'latest', maturity: 'released', author: 'TONY', provides: ['Demo', 'Demo::Plain', 'Demo::X', 'Demo::X::Boom'] }
+  const module = (documentation: string | null, path: string, extra = {}) => body({ distribution: 'Demo-Dist', release: 'Demo-Dist-0.004', documentation, path, ...extra })
+  const served = (changes: Record<string, unknown> = {}) => {
+    const routes: Record<string, unknown> = {
+      [`${API}/release/Demo-Dist`]: body(release),
+      [`${API}/module/Demo`]: module('Demo', 'lib/Demo.pm'),
+      [`${API}/module/Demo::Plain`]: module(null, 'lib/Demo/Plain.pm'),
+      [`${API}/module/Demo::X`]: module('Demo::X', 'lib/Demo/X.pm'),
+      [`${API}/module/Demo::X::Boom`]: module('Demo::X', 'lib/Demo/X.pm'),
+      [`${API}/pod/Demo`]: page('Demo', ['new', 'new-1']),
+      [`${API}/pod/Demo::X`]: page('Demo::X', ['Boom']),
+      [`${API}/source/TONY/Demo-Dist-0.004/lib/Demo.pm`]: source('package Demo;\n'),
+      [`${API}/source/TONY/Demo-Dist-0.004/lib/Demo/X.pm`]: source('package Demo::X;\npackage Demo::X::Boom;\n'),
+      ...changes,
+    }
+    return async (url: string) => (routes[url] ?? { status: 404, text: '', bytes: Buffer.alloc(0) }) as Awaited<ReturnType<Parameters<typeof observeDistribution>[0]>>
+  }
+  const sha = (text: string) => createHash('sha256').update(text).digest('hex')
+
+  it('records each provided package with its document, and each document with its file’s digest and fragments', async () => {
+    expect(await observeDistribution(served(), 'Demo-Dist')).toEqual({
+      author: 'TONY', release: '0.004',
+      // A package with no POD of its own is recorded as having none, and a shared file documents its subclass.
+      packages: { Demo: 'Demo', 'Demo::Plain': null, 'Demo::X': 'Demo::X', 'Demo::X::Boom': 'Demo::X' },
+      documents: {
+        Demo: { path: 'lib/Demo.pm', sha256: sha('package Demo;\n'), anchors: ['NAME', 'new', 'new-1'] },
+        'Demo::X': { path: 'lib/Demo/X.pm', sha256: sha('package Demo::X;\npackage Demo::X::Boom;\n'), anchors: ['NAME', 'Boom'] },
+      },
+    })
+  })
+
+  it('reads the fragments a page answers to: headings and items, each once, in order', () => {
+    expect(podAnchors('<h1 id="NAME">N</h1><h2 id="a">a</h2><dl><dt id="b,-c">b</dt></dl><p id="not-a-heading"></p><h2 id="a">again</h2>')).toEqual(['NAME', 'a', 'b,-c'])
+  })
+
+  it('refuses a release or a page that would make a link open the wrong thing', async () => {
+    const refuses = (changes: Record<string, unknown>, pattern: RegExp) => expect(observeDistribution(served(changes), 'Demo-Dist')).rejects.toThrow(pattern)
+    await refuses({ [`${API}/release/Demo-Dist`]: body({ ...release, status: 'cpan' }) }, /does not name it as a released distribution/)
+    await refuses({ [`${API}/release/Demo-Dist`]: body({ ...release, maturity: 'developer' }) }, /does not name it as a released distribution/)
+    await refuses({ [`${API}/release/Demo-Dist`]: body({ ...release, distribution: 'Other-Dist' }) }, /does not name it as a released distribution/)
+    await refuses({ [`${API}/module/Demo::Plain`]: module(null, 'lib/Demo/Plain.pm', { release: 'Demo-Dist-0.003' }) }, /files Demo::Plain under Demo-Dist-0\.003/)
+    // A client challenge is not a POD page, and a page that declares another module is not this one's.
+    await refuses({ [`${API}/pod/Demo`]: { status: 200, bytes: Buffer.alloc(0), text: '<title>Client Challenge</title><h1>Client Challenge</h1>' } }, /names "" in its NAME section/)
+    await refuses({ [`${API}/pod/Demo`]: page('Demo::Elsewhere', ['new']) }, /names "Demo::Elsewhere" in its NAME section/)
+    await refuses({ [`${API}/pod/Demo`]: { status: 503, bytes: Buffer.alloc(0), text: '' } }, /answered 503/)
+    await refuses({ [`${API}/module/Demo`]: module('Demo', 'bin/demo') }, /outside lib\//)
+  })
+})
+
+describe('the alternate documentation link on an API entry', () => {
+  // ApiEntry's imports need the Astro build, so the link cluster is compiled from its own source rather than loaded whole.
+  const entrySource = readFileSync(new URL('../src/components/api/ApiEntry.astro', import.meta.url), 'utf8')
+  const cluster = entrySource.slice(entrySource.indexOf('(source || alternate) && ('), entrySource.indexOf('\n        }\n        <a class="headerlink"'))
+  const entry = async (props: Record<string, unknown>) => {
+    const template = await loadAstroTemplate('components/api/ApiEntry.astro', {
+      stubs: { 'components/api/ApiEntry.astro': `---\nconst { source, alternate } = Astro.props\n---\n{${cluster}}` },
+    })
+    return withoutScope(await renderAstroTemplate(template, { props }))
+  }
+  const model = API_MODELS.perl!
+  const symbol = model.symbols.find((candidate) => candidate.id === 'LibTmux::Server::new')!
+
+  it('is the cluster the component renders, beside the permalink', () => {
+    expect(cluster).toMatch(/^\(source \|\| alternate\) && \(/)
+    expect(cluster).toContain('href={alternate.href}')
+    expect(entrySource).toContain('alternate?: (symbol: ApiSymbol) => ApiAlternate | undefined')
+    for (const file of ['ApiReference', 'ProductApiPage']) {
+      expect(readFileSync(new URL(`../src/components/api/${file}.astro`, import.meta.url), 'utf8'), file).toMatch(/alternate=\{\(entry\) => .*alternateDocs\(/)
+    }
+  })
+
+  it('renders the POD action beside the source link, with its release in the accessible name', async () => {
+    const alternate = podLink(model, symbol)!
+    const html = await entry({ source: 'https://example.test/source', alternate })
+    const anchors = [...html.matchAll(/<a class="api-source-anchor[^"]*" href="([^"]+)"[^>]*>([^<]+)<\/a>/g)].map((match) => [match[1], match[2]])
+    expect(anchors).toEqual([['https://example.test/source', 'source'], [alternate.href, alternate.label]])
+    expect(html).toContain(`aria-label="${alternate.title}"`)
+    expect(html).toContain('data-alternate-docs="metacpan-pod"')
+    expect(html).toContain('data-alternate-observation="source"')
+    // A page that documents other source says so in the markup too.
+    const other = await entry({ source: 'https://example.test/source', alternate: { ...alternate, differs: true } })
+    expect(other).toContain('data-alternate-observation="release"')
+  })
+
+  it('renders nothing where there is no alternate, and keeps the source link alone', async () => {
+    const html = await entry({ source: 'https://example.test/source' })
+    expect(html).not.toContain('data-alternate-docs')
+    expect(html).toContain('>source</a>')
+    expect(await entry({})).not.toContain('gp-sphinx-api-source-link')
+  })
+})
diff --git a/site/test/port-inventory.test.ts b/site/test/port-inventory.test.ts
index 012d45b1e..2be500db4 100644
--- a/site/test/port-inventory.test.ts
+++ b/site/test/port-inventory.test.ts
@@ -269,7 +269,7 @@ describe('port inventory', () => {
     }
     // Only these ecosystems host an API reference off site.
     expect(PORTS.filter((port) => entries(port.slug).some((entry) => entry.api)).map(({ slug }) => slug).sort())
-      .toEqual(['elixir', 'go', 'java', 'kotlin', 'rs', 'scala', 'swift'])
+      .toEqual(['elixir', 'go', 'java', 'kotlin', 'perl', 'rs', 'scala', 'swift'])
     // Go’s package page and its API reference are one URL on one host.
     for (const entry of entries('go')) expect(entry.api?.url, entry.id).toBe(entry.package?.url)
   })
@@ -302,6 +302,30 @@ describe('port inventory', () => {
     expect(published('elixir').map((entry) => entry.id)).toEqual(['libtmux', 'repository'])
   })
 
+  it('lists Perl’s three CPAN distributions with their MetaCPAN pages, and the command on its distribution’s page', () => {
+    const dist = (name: string) => `https://metacpan.org/dist/${name}`
+    const pod = (module: string) => `https://metacpan.org/pod/${module}`
+    expect(entries('perl').map((entry) => [entry.id, entry.kind, entry.status, entry.package?.url, entry.api?.url])).toEqual([
+      ['LibTmux', 'library', 'published', dist('LibTmux'), pod('LibTmux')],
+      ['LibTmux-Async', 'companion', 'published', dist('LibTmux-Async'), pod('LibTmux::Async')],
+      ['LibTmux-Workspace', 'companion', 'published', dist('LibTmux-Workspace'), pod('LibTmux::Workspace')],
+      ['repository', 'source', 'published', undefined, undefined],
+      ['libtmux-workspace', 'cli', 'published', dist('LibTmux-Workspace'), undefined],
+    ])
+    // Nothing claims the packages are unreleased, and source stays a link through its own entries.
+    for (const entry of entries('perl')) {
+      expect(entry.note, entry.id).toBeUndefined()
+      expect(entry.sourceAvailable, entry.id).toBeUndefined()
+      expect(sourceUrl(entry), entry.id).toMatch(/^https:\/\/github\.com\/libtmux\/libtmux-perl/)
+    }
+    expect(entries('perl').filter((entry) => entry.package).map((entry) => entry.package!.host)).toEqual(Array(4).fill('metacpan'))
+    // One host serves both pages with a different mark for each, as the Swift Package Index does.
+    expect(PACKAGE_HOSTS.metacpan).toMatchObject({ name: 'MetaCPAN', hostname: 'metacpan.org', icon: 'cpan' })
+    expect(API_HOSTS.metacpan).toMatchObject({ name: 'MetaCPAN POD', hostname: 'metacpan.org', icon: 'pod' })
+    // Async keeps its own page apart from core's, though its module and class names resemble core's.
+    expect(new Set(entries('perl').flatMap((entry) => [entry.package?.url, entry.api?.url]).filter(Boolean)).size).toBe(6)
+  })
+
   it('links nothing for an entry that is planned or configured but not published', () => {
     const lua = entries('lua')
     expect(lua.filter((entry) => entry.status !== 'published').map((entry) => [entry.id, entry.status])).toEqual([
diff --git a/site/test/port-landing.test.ts b/site/test/port-landing.test.ts
index 0e6c9f308..23e751838 100644
--- a/site/test/port-landing.test.ts
+++ b/site/test/port-landing.test.ts
@@ -20,6 +20,7 @@ const read = (path: string) => JSON.parse(readFileSync(new URL(path, import.meta
 
 /** Every product a port ships, as the selector offers it. */
 const PRODUCTS: Record<string, LandingProduct[]> = {
+  raku: ['core'],
   ocaml: ['core', 'workspace'],
   perl: ['core', 'workspace'],
   py: ['core', 'mcp', 'workspace'],
diff --git a/site/test/port-metadata.test.ts b/site/test/port-metadata.test.ts
index 419527fd8..4d145a451 100644
--- a/site/test/port-metadata.test.ts
+++ b/site/test/port-metadata.test.ts
@@ -5,7 +5,7 @@ import registry from '../src/data/registry.json'
 import { SERVERS } from '../src/lib/install-matrix'
 import { installsFor } from '../src/lib/registry'
 import { INVENTORY } from '../src/lib/port-inventory'
-import { PORT_BY_SLUG, PORTS, hasPackageInstalls, installCommand, portDestinations, portSourceUrl, productAvailable, productDescription, productIsConcept, type DocProduct } from '../src/lib/ports'
+import { PORT_BY_SLUG, PORTS, hasPackageInstalls, installCommand, portDestinations, portSourceUrl, productAvailable, productDescription, productIsConcept, workspaceInstallGuidance, type DocProduct } from '../src/lib/ports'
 import { DESTINATIONS } from './fixtures/port-destinations'
 
 it('keeps explicitly excluded products out of installation and concept navigation', () => {
@@ -34,7 +34,7 @@ describe('Haskell port metadata', () => {
     expect(installCommand(haskell, { status: 'unpublished', version: null, release: null, tag: null }).code)
       .toContain('location: https://github.com/libtmux/libtmux-haskell')
     expect(INVENTORY.haskell.map((entry) => [entry.id, entry.status])).toEqual([
-      ['libtmux-haskell', 'published'], ['repository', 'published'], ['libtmux-haskell-workspace', 'planned'],
+      ['libtmux-haskell', 'configured-unpublished'], ['repository', 'published'], ['libtmux-haskell-workspace', 'planned'],
     ])
     const workspace = INVENTORY.haskell[2]
     expect(workspace.path).toBeUndefined()
@@ -70,7 +70,10 @@ describe('Ruby port metadata', () => {
       'libtmux-mcp',
       'libtmux-workspace',
     ])
-    expect(Object.values(registry.ports.ruby.packages).every((entry) => entry.version === '0.1.0')).toBe(true)
+    // The four gems release together, so each carries the core's version, whatever it is today.
+    const gems = Object.values(registry.ports.ruby.packages)
+    expect(gems.every((entry) => entry.status === 'release' && entry.version === registry.ports.ruby.version)).toBe(true)
+    expect(registry.ports.ruby.version).toMatch(/^\d+\.\d+\.\d+$/)
   })
 
   it('offers install or build instructions for each available workspace app', () => {
@@ -104,12 +107,10 @@ describe('Lua port metadata', () => {
       registry: { name: 'LuaRocks', icon: 'luarocks' },
       productAvailability: { mcp: 'excluded', workspace: 'excluded' },
     })
-    expect(registry.ports.lua).toMatchObject({
-      status: 'release',
-      version: '0.1.0-1',
-      release: '0.1.0-1',
-      tag: 'v0.1.0',
-    })
+    // LuaRocks names a release `<version>-<revision>`; the tag names the version alone.
+    const { version } = registry.ports.lua
+    expect(version).toMatch(/^\d+\.\d+\.\d+-\d+$/)
+    expect(registry.ports.lua).toMatchObject({ status: 'release', release: version, tag: `v${version!.replace(/-\d+$/, '')}` })
   })
 })
 
@@ -171,6 +172,75 @@ describe('workspace CLI availability', () => {
   })
 })
 
+describe('Perl CPAN publication', () => {
+  const perl = PORT_BY_SLUG.perl!
+  const package_ = (id: string) => perl.packages!.find((entry) => entry.id === id)!
+  const copyable = (port: typeof perl) => [
+    ...port.installs.flatMap(({ code, note }) => [code, note ?? '']),
+    ...(port.packages ?? []).flatMap((entry) => (entry.installs ?? []).flatMap(({ code, note }) => [code, note ?? ''])),
+    ...Object.values(port.installForms).map(({ code }) => code), port.installNote ?? '', port.initProject.code,
+  ]
+
+  it('registers MetaCPAN as the package host and its POD as the reference, for the port and for each package', () => {
+    expect(perl.registry).toEqual({ name: 'MetaCPAN', url: 'https://metacpan.org/dist/LibTmux', icon: 'cpan' })
+    expect(perl.ecosystemHost).toMatchObject({ name: 'MetaCPAN POD', url: 'https://metacpan.org/pod/LibTmux' })
+    expect(perl.packages!.map(({ id, registry, reference }) => [id, registry, reference])).toEqual([
+      ['core', 'https://metacpan.org/dist/LibTmux', 'https://metacpan.org/pod/LibTmux'],
+      ['async', 'https://metacpan.org/dist/LibTmux-Async', 'https://metacpan.org/pod/LibTmux::Async'],
+      ['workspace', 'https://metacpan.org/dist/LibTmux-Workspace', 'https://metacpan.org/pod/LibTmux::Workspace'],
+    ])
+    // The workspace product's page names its own distribution, and keeps the source directory beside it.
+    const { source, registry: packageRegistry, ecosystem } = portDestinations({ port: perl, product: 'workspace' })
+    expect(packageRegistry).toEqual({ name: 'MetaCPAN', url: 'https://metacpan.org/dist/LibTmux-Workspace', icon: 'cpan' })
+    expect(source.url).toBe('https://github.com/libtmux/libtmux-perl/tree/master/packages/workspace')
+    expect(ecosystem).toBeUndefined()
+  })
+
+  it('installs each distribution from CPAN first and keeps the source checkout as the explicit alternative', () => {
+    expect(perl.installs.map(({ label, code }) => [label, code])).toEqual([
+      ['cpm', 'cpm install --global LibTmux'],
+      ['cpm (source)', 'git clone https://github.com/libtmux/libtmux-perl.git && \\\n  cd libtmux-perl && \\\n  cpm install --global ./packages/core'],
+    ])
+    expect(package_('async').installs!.map(({ label, code }) => [label, code])).toEqual([
+      ['cpm', 'cpm install --global LibTmux::Async'], ['cpm (source)', 'cpm install --global ./packages/async'],
+    ])
+    expect(package_('workspace').installs!.map(({ label, code }) => [label, code])).toEqual([
+      ['cpm', 'cpm install --global LibTmux::Workspace'], ['cpm (source)', 'cpm install --global ./packages/workspace'],
+    ])
+    expect(perl.installForms.release.code).toBe('cpm install --global LibTmux')
+    expect(perl.installForms.git.code).toContain('git clone https://github.com/libtmux/libtmux-perl.git')
+    expect(hasPackageInstalls(perl, 'async') && hasPackageInstalls(perl, 'workspace')).toBe(true)
+  })
+
+  it('says nothing that calls the distributions unpublished', () => {
+    for (const text of copyable(perl)) expect(text).not.toMatch(/unpublished|no cpan release|not published|do not identify published/i)
+    expect(workspaceInstallGuidance(perl)).toBe('The `libtmux-workspace` CLI is published to MetaCPAN. Pin its version when automation depends on its output.')
+    expect(perl.workspaceCliAvailability).toBe('published')
+    expect(productDescription(perl, 'workspace')).toContain('published')
+  })
+
+  it('records the CPAN release with its decimal version and tag, not a dotted rewrite of them', () => {
+    const entry = registry.ports.perl
+    expect(entry).toMatchObject({ status: 'release' })
+    expect(entry.version).toMatch(/^\d+\.\d{3}$/)
+    expect(entry.tag).toBe(`v${entry.version}`)
+    expect(entry.release).toBe(entry.version)
+    for (const dist of ['LibTmux', 'LibTmux-Async', 'LibTmux-Workspace']) {
+      expect(entry.packages![dist as keyof typeof entry.packages], dist).toMatchObject({ status: 'release', version: entry.version, tag: entry.tag })
+    }
+    expect(installCommand(perl, entry as Parameters<typeof installCommand>[1]).code).toBe('cpm install --global LibTmux')
+  })
+
+  it('keeps MCP excluded and async an optional companion of core', () => {
+    expect(perl.productAvailability).toEqual({ workspace: 'available', mcp: 'excluded' })
+    expect(productAvailable(perl, 'mcp')).toBe(false)
+    expect(perl.packages!.some((entry) => entry.id === 'mcp')).toBe(false)
+    expect(new Set(INVENTORY.perl!.map((entry) => entry.product))).toEqual(new Set(['core', 'workspace']))
+    expect(package_('async').require).toBe('LibTmux::Async::Server')
+    expect(package_('async').installs![0]!.note).toMatch(/Future and IO::Async/)
+  })
+})
+
 describe('port destinations', () => {
   afterEach(() => {
     vi.unstubAllEnvs()
diff --git a/site/test/prerelease-notice.test.ts b/site/test/prerelease-notice.test.ts
index a81d781c6..fa3e97c89 100644
--- a/site/test/prerelease-notice.test.ts
+++ b/site/test/prerelease-notice.test.ts
@@ -150,20 +150,35 @@ describe('prerelease notice ownership', () => {
     expect(html).toContain('libtmux-haskell has not been released. Its API may change during development.')
     expect(html).toContain('>Unreleased</strong>')
     expect(html).not.toContain('libtmux is released')
-    const tagged = await render('/en/julia/latest/core/', 'core', 'julia')
+    // A git tag is not a release where no registry carries the package.
+    const julia = await render('/en/julia/latest/core/', 'core', 'julia')
+    expect(julia).toContain('LibTmux has not been released. Its API may change during development.')
+    expect(julia).not.toContain('libtmux is released')
+    // C++ resolves its releases from tags, so its tag is one.
+    const tagged = await render('/en/cxx/latest/core/', 'core', 'cxx')
     expect(tagged).toContain('libtmux is released')
     expect(tagged).not.toContain('has not been released')
   })
 
   it('labels unreleased native packages as unreleased', async () => {
     for (const path of ['reference/libtmux-selection', 'workspace']) {
-      const html = await render(`/en/perl/latest/${path}/`, path, 'perl')
+      const html = await render(`/en/haskell/latest/${path}/`, path, 'haskell')
       expect(html).toContain('>Unreleased</strong>')
       expect(html).toContain('has not been released')
       expect(html).not.toContain('libtmux is released')
     }
   })
 
+  it('labels the Perl distributions CPAN carries as released', async () => {
+    expect(registryFor('perl')).toMatchObject({ status: 'release' })
+    for (const path of ['reference/libtmux-selection', 'workspace']) {
+      const html = await render(`/en/perl/latest/${path}/`, path, 'perl')
+      expect(html).toContain('libtmux is released')
+      expect(html).not.toContain('>Unreleased</strong>')
+      expect(html).not.toContain('has not been released')
+    }
+  })
+
   it('identifies a source-only port as unreleased', async () => {
     const html = await render('/en/lisp/latest/', '', 'lisp')
     expect(html).toContain('>Unreleased</strong>')
diff --git a/site/test/product-exclusion.test.ts b/site/test/product-exclusion.test.ts
index 9b0a77cbc..3f8ad96d5 100644
--- a/site/test/product-exclusion.test.ts
+++ b/site/test/product-exclusion.test.ts
@@ -13,8 +13,10 @@ import { DOC_PRODUCTS, PORT_BY_SLUG, PORTS, productAvailable, productExcluded, t
  * through `parentLibrary`.
  */
 const WITHOUT: Record<DocProduct, readonly string[]> = {
-  mcp: ['lua', 'powershell', 'erlang', 'elixir', 'haskell', 'lisp', 'ocaml', 'perl'],
-  workspace: ['lua', 'elixir', 'haskell', 'erlang'],
+  mcp: ['lua', 'powershell', 'erlang', 'elixir', 'haskell', 'lisp', 'ocaml', 'perl',
+    'raku'],
+  workspace: ['lua', 'elixir', 'haskell', 'erlang',
+    'raku'],
 }
 
 /** Product roots that were public before their port stopped claiming the product. */
diff --git a/site/test/product-status.test.ts b/site/test/product-status.test.ts
index 6297a31e2..938774aff 100644
--- a/site/test/product-status.test.ts
+++ b/site/test/product-status.test.ts
@@ -10,9 +10,9 @@ import { loadAstroTemplate, renderAstroTemplate } from './astro-templates'
 
 const entry = (overrides: Partial<RegistryEntry>): RegistryEntry => ({ status: 'prerelease', version: null, release: null, tag: null, ...overrides })
 
-// What the registry resolver recorded for Julia when its first final release
-// was tagged and General did not carry it yet.
-const JULIA_FINAL_TAG: RegistryEntry = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }
+// What the registry resolver records for Julia when a final version is tagged
+// and General does not carry it: no registry release, so unreleased whatever the tag says.
+const JULIA_FINAL_TAG: RegistryEntry = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }
 
 describe('release maturity', () => {
   it('reads Cabal numeric releases only when that grammar is declared', () => {
@@ -49,8 +49,8 @@ describe('release maturity', () => {
     expect(() => releaseMaturity(entry({ version: '0.1.0-dev.3' }))).toThrow(/no release stage in "0.1.0-dev.3"/)
   })
 
-  it('reads the live Julia entry, a final tag that General does not carry yet, as 0.x', () => {
-    expect(releaseMaturity(JULIA_FINAL_TAG)).toBe('0.x')
+  it('reads the live Julia entry, a final tag that General does not carry, as unreleased', () => {
+    expect(releaseMaturity(JULIA_FINAL_TAG)).toBe('unreleased')
   })
 
   it.each([
@@ -148,21 +148,21 @@ describe('product status', () => {
     }
   })
 
-  it('badges Julia 0.x from its final tag and states the line without naming a registry', async () => {
+  it('badges Julia unreleased whatever its tag says, and states a line that claims no release', async () => {
     const julia = PORT_BY_SLUG.julia!
     const status = productStatus(julia, 'core', { schema: 2, ports: { julia: JULIA_FINAL_TAG } })
-    expect(status).toBe('0.x')
-    // Python's releases are on PyPI and Julia's is not on General; one line has to be true of both.
-    expect(productStatusLine('0.x')).not.toMatch(/registry/i)
+    expect(status).toBe('unreleased')
+    expect(productStatusLine('unreleased')).not.toMatch(/release/i)
     const html = await renderAstroTemplate(await loadAstroTemplate('components/StatusBadge.astro'), {
       props: { status, product: julia.projectName, id: 'julia-core-status' },
     })
-    expect(html).toContain('data-status="0.x"')
-    expect(html).toContain(`<span class="status-toggletip__line">${productStatusLine('0.x')}</span>`)
+    expect(html).toContain('data-status="unreleased"')
+    expect(html).toContain(`<span class="status-toggletip__line">${productStatusLine('unreleased')}</span>`)
   })
 
   it.each([
-    ['General lists nothing', null, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }, '0.x'],
+    // No registry release: the resolver records the tag and marks the entry unreleased.
+    ['General lists nothing', null, { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }, 'unreleased'],
     ['General lists only 0.1.0-alpha.2', ['0.1.0-alpha.2'], { status: 'prerelease', version: '0.1.0-alpha.2', release: null, tag: 'v0.1.0-alpha.2' }, 'alpha'],
     ['General lists 0.1.0', ['0.1.0'], { status: 'release', version: '0.1.0', release: '0.1.0', tag: 'v0.1.0' }, '0.x'],
   ] as const)('reads the newest release tag only while the registry lists no release: %s', (_state, published, resolved, stage) => {
diff --git a/site/test/prompts.test.ts b/site/test/prompts.test.ts
index 1c8748e33..677bcd906 100644
--- a/site/test/prompts.test.ts
+++ b/site/test/prompts.test.ts
@@ -381,25 +381,28 @@ describe('registry data', () => {
   })
 
   it('sends an agent looking for a final release only where the newest tag is not already one', () => {
-    const julia = PORT_BY_SLUG.julia!
-    const prompt = (entry: RegistryEntry) => composePrompt({
-      port: julia, released: isReleaseSeries(releaseMaturity(entry)), install: installCommand(julia, entry),
-      wording: releaseWording(julia, entry), ctx, topicId: 'setup',
+    const prompt = (port: Port, entry: RegistryEntry) => composePrompt({
+      port, released: isReleaseSeries(releaseMaturity(entry)), install: installCommand(port, entry),
+      wording: releaseWording(port, entry), ctx, topicId: 'setup',
     }).replace(/\s+/g, ' ')
+    // C++ resolves its releases from tags, so a final tag is a final release.
+    const cxx = PORT_BY_SLUG.cxx!
     const finalTag: RegistryEntry = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }
-    expect(prompt(finalTag)).toContain('if you need a different version.')
-    expect(prompt(finalTag)).not.toContain('prefer a final release')
-    expect(prompt({ ...finalTag, tag: 'v0.1.0-alpha.2' })).toContain('prefer a final release if there now is one.')
+    expect(prompt(cxx, finalTag)).toContain('if you need a different version.')
+    expect(prompt(cxx, finalTag)).not.toContain('prefer a final release')
+    expect(prompt(cxx, { ...finalTag, tag: 'v0.1.0-alpha.2' })).toContain('prefer a final release if there now is one.')
+    // Julia has no registry release, so the resolver writes it as unreleased and a final tag does not change that.
+    expect(prompt(PORT_BY_SLUG.julia!, { ...finalTag, maturity: 'unreleased' })).toContain('prefer a final release if there now is one.')
   })
 
   it('composes the site’s prompt from the entry the registry holds', () => {
     const julia = PORT_BY_SLUG.julia!
     const recorded = REGISTRY.ports.julia!
-    // What the deploy's resolver wrote once v0.1.0 was tagged and General did not carry it.
-    REGISTRY.ports.julia = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0' }
+    // What the deploy's resolver writes once v0.1.0 is tagged and General does not carry it.
+    REGISTRY.ports.julia = { status: 'unpublished', version: null, release: null, tag: 'v0.1.0', maturity: 'unreleased' }
     try {
-      expect(promptInputs(julia, ctx).released).toBe(true)
-      expect(promptPartsFor(julia, ctx).setup.replace(/\s+/g, ' ')).toContain('if you need a different version.')
+      expect(promptInputs(julia, ctx).released).toBe(false)
+      expect(promptPartsFor(julia, ctx).setup.replace(/\s+/g, ' ')).toContain('prefer a final release if there now is one.')
     } finally {
       REGISTRY.ports.julia = recorded
     }
diff --git a/site/test/source-only-inventory.test.ts b/site/test/source-only-inventory.test.ts
index b6620dce3..a7aa0e8a0 100644
--- a/site/test/source-only-inventory.test.ts
+++ b/site/test/source-only-inventory.test.ts
@@ -4,8 +4,10 @@ import { portHeaderLinks } from '../src/lib/header-links'
 import { INVENTORY, type InventoryEntry } from '../src/lib/port-inventory'
 import { PORT_BY_SLUG } from '../src/lib/ports'
 
+// Perl is published on CPAN, so this entry keeps its source but not its registry destinations or its status.
+const { api: _api, ...published } = INVENTORY.perl![0]!
 const library: InventoryEntry = {
-  ...INVENTORY.perl![0]!, sourceAvailable: true,
+  ...published, status: 'configured-unpublished', sourceAvailable: true, note: 'Install from verified source.',
   package: { host: 'npm', url: 'https://www.npmjs.com/package/unpublished-test' },
 }
 
diff --git a/site/test/stage-port-docs.test.ts b/site/test/stage-port-docs.test.ts
index dda164d29..39c6d6bd2 100644
--- a/site/test/stage-port-docs.test.ts
+++ b/site/test/stage-port-docs.test.ts
@@ -257,11 +257,12 @@ describe('staged port guide links', () => {
     ])
     else if (port === 'clojure') expect(cards[1].label).toBe('Captures, effects and streams')
     else if (port === 'perl' || port === 'erlang') expect(cards[1].label).toBe('Installation')
+    else if (port === 'raku') expect(cards.map((card: { label: string }) => card.label)).toEqual(['Getting started'])
     else if (port !== 'ocaml') expect(cards[1].label).toBe('Attaching to tmux')
     if (port === 'perl') {
       const example = files.get('perl/examples/orchestration/index.md')!
       const body = /^---\n[\s\S]*?\n---\n\n([\s\S]*)$/.exec(example)![1]
-      expect(body).toMatch(/^Constructing `LibTmux::Server`/)
+      expect(body).toMatch(/^## Start with a complete program/)
     }
     for (const section of ['examples', 'topics']) {
       const page = files.get(`${port}/${section}/index.md`)
diff --git a/site/test/symbol-form.test.ts b/site/test/symbol-form.test.ts
index a2bb4c709..572032e19 100644
--- a/site/test/symbol-form.test.ts
+++ b/site/test/symbol-form.test.ts
@@ -20,6 +20,7 @@ interface Row {
 const ROWS: Record<string, Row> = {
   ocaml: { type: ['Libtmux::Snapshot.t', 'Libtmux.Snapshot.t'], method: ['Client.capture', 'Client.capture', 'Libtmux_unix.Client.capture'], function: ['Query.matching', 'Query.matching', 'Libtmux.Query.matching'], property: ['Generation.value', 'Generation.value', 'Libtmux.Generation.t.value'], member: ['error', 'No_match', 'Libtmux.Cardinality.error.No_match', 'No_match', 'No_match'] },
   perl: { type: ['LibTmux::Server', 'LibTmux::Server'], method: ['LibTmux::Server/snapshot', 'LibTmux::Server/snapshot', 'LibTmux::Server::snapshot'], function: ['grep', 'grep', 'LibTmux::Selection::grep'], property: ['Pane/width', 'Pane/width', 'LibTmux::Pane::width'], member: ['Mode', 'active', 'LibTmux::Mode::active', 'active', 'active'] },
+  raku: { type: ['LibTmux::Server', 'LibTmux::Server'], method: ['Server.start', 'Server.start', 'LibTmux::Server.start'], function: ['Layout.decode-layout', 'Layout.decode-layout', 'LibTmux::Layout.decode-layout'], property: ['Pane.width', 'Pane.width', 'LibTmux::Model::Pane.width'], member: ['Outcome', 'Complete', 'LibTmux::Types::Outcome.Complete', 'Complete', 'Complete'] },
   clojure: { type: ['libtmux.core', 'libtmux.core'], method: ['libtmux.core/open!', 'libtmux.core/open!', 'libtmux.core/open!'], function: ['active?', 'active?', 'libtmux.core/active?'], property: [':pane/id', ':pane/id', 'pane/id'], member: ['Direction', ':right', ':right', ':right', ':right'] },
   py: { type: ['libtmux::Server', 'libtmux.Server'], method: ['Server.list_sessions', 'Server.list_sessions()', 'libtmux.Server.list_sessions'], function: ['get_version', 'get_version()', 'libtmux.get_version'], property: ['Server.socket_name', 'Server.socket_name', 'libtmux.Server.socket_name'], member: ['Direction', 'UP', 'libtmux.Direction.UP', 'Direction.UP', 'Direction.UP'] },
   ts: { type: ['server.Server', 'server.Server'], method: ['Server.listSessions', 'Server.listSessions()', 'server.Server.listSessions'], function: ['parseWorkspace', 'parseWorkspace()', 'config.parseWorkspace'], property: ['Pane.id', 'Pane.id', 'pane.Pane.id'], member: ['Direction', 'Up', 'constants.Direction.Up', 'Direction.Up', 'Direction.Up'] },
diff --git a/site/test/tmux-usage-raku.outer.test.ts b/site/test/tmux-usage-raku.outer.test.ts
new file mode 100644
index 000000000..dbae9b43c
--- /dev/null
+++ b/site/test/tmux-usage-raku.outer.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { nativeRakuScan, scanRaku } from '../../scripts/lib/tmux-usage-raku.mjs'
+import { settleCandidates, sweepCandidates } from '../../scripts/lib/tmux-usage-sweep.mjs'
+
+// Outer: the native compiler parses trusted source in a subprocess.
+describe('Raku command source', () => {
+  it('uses native declarations and literals without crediting documentation or builders', () => {
+    const text = [
+      'class Pane {',
+      '  # method fake { "kill-pane" }',
+      '  method capture { say <capture-pane -p> }',
+      '  method label { q[method fake { "kill-pane" }] }',
+      '  method callback { my &invoke = sub (|capture) { say <display-message> }; invoke() }',
+      '}',
+      '=begin pod',
+      'method fake { "kill-pane" }',
+      '=end pod',
+    ].join('\n')
+    const native = nativeRakuScan(text)
+    const model = JSON.parse(readFileSync(new URL('../src/data/api/raku.json', import.meta.url), 'utf8'))
+    expect(native.compiler).toBe(model.nativeProvenance.exporter.compiler)
+    const scanned = scanRaku(text, native, { commands: new Set(['capture-pane', 'kill-pane', 'display-message']), known: new Set(['capture-pane', 'kill-pane', 'display-message']) })
+    expect(scanned.functions.map((fn: { name: string; owner?: string; start: number; end: number }) =>
+      [fn.name, fn.owner, fn.start, fn.end])).toEqual([
+      ['capture', 'Pane', 3, 3], ['label', 'Pane', 4, 4], ['callback', 'Pane', 5, 5],
+    ])
+    expect(scanned.functions[0].sites).toEqual([expect.objectContaining({ command: 'capture-pane', line: 3, dispatch: null })])
+    expect(scanned.functions[1].sites).toEqual([])
+    expect(scanned.functions[2].sites).toEqual([expect.objectContaining({ command: 'display-message', line: 5, dispatch: null })])
+    expect(() => scanRaku(`${text}\n`, native, { commands: new Set(), known: new Set() })).toThrow('exact bytes')
+    const { candidates } = sweepCandidates({ port: 'raku', commands: ['capture-pane'], has: new Set(), symbols: [
+      { id: 'Pane.capture', name: 'capture', parentName: 'Pane', file: 'lib/Pane.rakumod', kind: 'method' },
+    ] })
+    expect(settleCandidates({ port: 'raku', candidates, reviews: [] }).unreviewed).toHaveLength(1)
+  })
+})